def getPeakFeatures(): net = DecafNet() features = numpy.zeros((number_sequences, feature_length)) labels = numpy.zeros((number_sequences, 1)) counter = 0 # Maybe sort them for participant in os.listdir(os.path.join(data_dir, image_dir)): for sequence in os.listdir( os.path.join(data_dir, image_dir, participant)): if sequence != ".DS_Store": image_files = sorted( os.listdir( os.path.join(data_dir, image_dir, participant, sequence))) image_file = image_files[-1] print counter, image_file imarray = cv2.imread( os.path.join(data_dir, image_dir, participant, sequence, image_file)) imarray = cv2.cvtColor(imarray, cv2.COLOR_BGR2GRAY) scores = net.classify(imarray, center_only=True) features[counter] = net.feature(feature_level) #.flatten() label_file = open( os.path.join(data_dir, label_dir, participant, sequence, image_file[:-4] + "_emotion.txt")) labels[counter] = eval(label_file.read()) label_file.close() counter += 1 numpy.save("featuresPeak5", features) numpy.save("labelsPeak5", labels)
def full_check_decaf(win_slide=5, win_size=1024, blob_name='fc6_cudanet_out'): from decaf.scripts.imagenet import DecafNet net = DecafNet() clf = joblib.load("420_decaf/classifier_decaf.pkl") g_raster = gdal.Open('20-21-22-part2.tif') # test.tif # plt.axis('off') # f, axarr = plt.subplots(n, n) result = {} cols = range(0, g_raster.RasterXSize - win_size, win_slide) rows = range(0, g_raster.RasterYSize - win_size, win_slide) full = len(rows) * len(cols) count = 0 pbar = progressbar.ProgressBar(maxval=full).start() for i in range(0, g_raster.RasterXSize - win_size, win_slide): for j in range(0, g_raster.RasterYSize - win_size, win_slide): img = get_sample(g_raster, i, j, win_size) net.classify(img, True) tmp = net.feature(blob_name) #与训练时候保持一致 result[(j,i)] = clf.predict(tmp) if result[(j,i)] == 2: io.imsave("420_decaf/slide_target/%s_%s_%s_%s.png" % (j, i, j+win_size, i+win_size), img) pbar.update(count+1) count = count + 1 pbar.finish() arr = np.ones((len(rows), len(cols))) for k, v in result.items(): if v != 0 and v[0] == 2: arr[k[0]/win_slide, k[1]/win_slide] = v[0] return arr
def getMoreFeatures(): net = DecafNet() features = [] labels = [] counter = 0 for participant in os.listdir(os.path.join(data_dir, image_dir)): for sequence in os.listdir( os.path.join(data_dir, image_dir, participant)): if sequence != ".DS_Store": image_files = sorted( os.listdir( os.path.join(data_dir, image_dir, participant, sequence))) cutoff = len(image_files) / 2 image_files = image_files[cutoff::] label_file = open( os.path.join(data_dir, label_dir, participant, sequence, image_files[-1][:-4] + "_emotion.txt")) label = eval(label_file.read()) label_file.close() for image_file in image_files: print counter, image_file imarray = numpy.asarray( Image.open( os.path.join(data_dir, image_dir, participant, sequence, image_file))) scores = net.classify(imarray, center_only=True) features.append(net.feature(feature_level)) labels.append(label) counter += 1 numpy.save("featuresMore", numpy.array(features)) numpy.save("labelsMore", numpy.array(labels))
def getMoreFeatures(): net = DecafNet() features = [] labels = [] counter = 0 for participant in os.listdir(os.path.join(data_dir,image_dir)): for sequence in os.listdir(os.path.join(data_dir,image_dir, participant)): if sequence != ".DS_Store": image_files = sorted(os.listdir(os.path.join(data_dir,image_dir, participant,sequence))) cutoff = len(image_files)/2 image_files = image_files[cutoff::] label_file = open(os.path.join(data_dir,label_dir, participant,sequence,image_files[-1][:-4]+"_emotion.txt")) label = eval(label_file.read()) label_file.close() for image_file in image_files: print counter, image_file imarray = numpy.asarray(Image.open(os.path.join(data_dir,image_dir, participant,sequence,image_file))) scores = net.classify(imarray, center_only=True) features.append(net.feature(feature_level)) labels.append(label) counter += 1 numpy.save("featuresMore",numpy.array(features)) numpy.save("labelsMore",numpy.array(labels))
def getPeakFaceFeatures(): net = DecafNet() cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml') features = numpy.zeros((number_sequences,feature_length)) labels = numpy.zeros((number_sequences,1)) counter = 0 # Maybe sort them for participant in os.listdir(os.path.join(data_dir,image_dir)): for sequence in os.listdir(os.path.join(data_dir,image_dir, participant)): if sequence != ".DS_Store": image_files = sorted(os.listdir(os.path.join(data_dir,image_dir, participant,sequence))) image_file = image_files[-1] print counter, image_file imarray = cv2.imread(os.path.join(data_dir,image_dir, participant,sequence,image_file)) imarray = cv2.cvtColor(imarray,cv2.COLOR_BGR2GRAY) rects = cascade.detectMultiScale(imarray, 1.3, 3, cv2.cv.CV_HAAR_SCALE_IMAGE, (150,150)) if len(rects) > 0: facerect=rects[0] imarray = imarray[facerect[1]:facerect[1]+facerect[3], facerect[0]:facerect[0]+facerect[2]] scores = net.classify(imarray, center_only=True) features[counter] = net.feature(feature_level).flatten() label_file = open(os.path.join(data_dir,label_dir, participant,sequence,image_file[:-4]+"_emotion.txt")) labels[counter] = eval(label_file.read()) label_file.close() counter += 1 numpy.save("featuresPeakFace5",features) numpy.save("labelsPeakFace5",labels)
def label(data_path, number_of_labels=1, equal_weights=True): """ Create annotation files for directories of pictures. Number of labels returned can be adjusted. Equal weighting of predictions. """ net = DecafNet() entities = os.listdir(data_path) for entity in entities: labels = [] pictures = os.listdir(os.path.join(data_path,entity)) for picture in pictures: imarray = numpy.array(Image.open(os.path.join(data_path,entity,picture))) scores = net.classify(imarray) predictions = net.top_k_prediction(scores,number_of_labels) # Format:([confidence],[labels]) labels.extend(predictions[1]) if equal_weights: prediction = max(set(labels),key=labels.count) elif confidence_weights: pass with open("label.txt","w") as opened_file: opened_file.write(prediction)
def __init__( self, layer_name, model_path='dist/decaf-release/model/imagenet.decafnet.epoch90', meta_path='dist/decaf-release/model/imagenet.decafnet.meta'): self.layer_name = layer_name self.net = DecafNet(model_path, meta_path) self.transforms = [NopTransform()]
def fit(self, X=None, y=None): from decaf.scripts.imagenet import DecafNet # soft dep if self.net_ is None: self.net_ = DecafNet( self.pretrained_params, self.pretrained_meta, ) return self
def __init__(self, decaf_folder=None, classifer_file=None): if decaf_folder is None: decaf_folder = '../models/imagenet_pretrained/' if classifer_file is None: classifer_file = "../models/lg_classifier_public" self.net = DecafNet( path.join(decaf_folder, 'imagenet.decafnet.epoch90'), path.join(decaf_folder, 'imagenet.decafnet.meta')) self.feat_layer = 'fc6_cudanet_out' self.classifier = cPickle.load(open(classifer_file, "r"))
class AVIClassifier(object): def __init__(self, decaf_folder = None, classifer_file = None): if decaf_folder is None: decaf_folder = '../models/imagenet_pretrained/' if classifer_file is None: classifer_file = "../models/lg_classifier_public" self.net = DecafNet(path.join(decaf_folder, 'imagenet.decafnet.epoch90'), path.join(decaf_folder, 'imagenet.decafnet.meta')) self.feat_layer = 'fc6_cudanet_out' self.classifier = cPickle.load(open(classifer_file, "r")) def predict(self, img): im = img_as_ubyte(color.rgb2gray(img)) scores = self.net.classify(im, center_only = True) feats = self.net.feature(self.feat_layer).flatten() defect_probs = self.classifier.predict_proba(feats) return sorted(zip(self.classifier.classes_, defect_probs[0]), key = lambda (cls, prob): prob, reverse=True) def class_names(self): return self.classifier.classes_
def __init__(self, decaf_folder = None, classifer_file = None): if decaf_folder is None: decaf_folder = '../models/imagenet_pretrained/' if classifer_file is None: classifer_file = "../models/lg_classifier_public" self.net = DecafNet(path.join(decaf_folder, 'imagenet.decafnet.epoch90'), path.join(decaf_folder, 'imagenet.decafnet.meta')) self.feat_layer = 'fc6_cudanet_out' self.classifier = cPickle.load(open(classifer_file, "r"))
def __init__(self, model_spec_filename, model_filename=None,\ wnid_words_filename=None, center_only=False, wnid_subset = []): """ *** PRIVATE CONSTRUCTOR *** """ # the following is just an hack to allow retro-compatibility # with existing code if isinstance(model_spec_filename, NetworkDecafParams): params = model_spec_filename model_spec_filename = params.model_spec_filename model_filename = params.model_filename wnid_words_filename = params.wnid_words_filename center_only = params.center_only wnid_subset = params.wnid_subset if wnid_subset != []: print 'Warning: subset of labels not supported yet' else: assert isinstance(model_spec_filename, str) assert model_filename != None assert wnid_words_filename != None # load Decaf model self.net_ = DecafNet(model_filename, model_spec_filename) self.center_only_ = center_only # build a dictionary label --> description self.dict_label_desc_ = {} dict_desc_label = {} fd = open(wnid_words_filename) for line in fd: temp = line.strip().split('\t') wnid = temp[1].strip() self.dict_label_desc_[wnid] = temp[2].strip() dict_desc_label[temp[2].split(',')[0]] = wnid fd.close() # build a dictionary label --> label_id self.dict_label_id_ = {} self.labels_ = [] for i, desc in enumerate(self.net_.label_names): self.dict_label_id_[dict_desc_label[desc]] = i self.labels_.append(dict_desc_label[desc]) # Load the mean vector from file # mean of 3 channels self.net_.mean_img = np.mean(np.mean(self.net_._data_mean, axis=1), axis=0)
def getPeakFaceFeatures(): net = DecafNet() cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml') features = numpy.zeros((number_sequences, feature_length)) labels = numpy.zeros((number_sequences, 1)) counter = 0 # Maybe sort them for participant in os.listdir(os.path.join(data_dir, image_dir)): for sequence in os.listdir( os.path.join(data_dir, image_dir, participant)): if sequence != ".DS_Store": image_files = sorted( os.listdir( os.path.join(data_dir, image_dir, participant, sequence))) image_file = image_files[-1] print counter, image_file imarray = cv2.imread( os.path.join(data_dir, image_dir, participant, sequence, image_file)) imarray = cv2.cvtColor(imarray, cv2.COLOR_BGR2GRAY) rects = cascade.detectMultiScale(imarray, 1.3, 3, cv2.cv.CV_HAAR_SCALE_IMAGE, (150, 150)) if len(rects) > 0: facerect = rects[0] imarray = imarray[facerect[1]:facerect[1] + facerect[3], facerect[0]:facerect[0] + facerect[2]] scores = net.classify(imarray, center_only=True) features[counter] = net.feature(feature_level).flatten() label_file = open( os.path.join(data_dir, label_dir, participant, sequence, image_file[:-4] + "_emotion.txt")) labels[counter] = eval(label_file.read()) label_file.close() counter += 1 numpy.save("featuresPeakFace5", features) numpy.save("labelsPeakFace5", labels)
class AVIClassifier(object): def __init__(self, decaf_folder=None, classifer_file=None): if decaf_folder is None: decaf_folder = '../models/imagenet_pretrained/' if classifer_file is None: classifer_file = "../models/lg_classifier_public" self.net = DecafNet( path.join(decaf_folder, 'imagenet.decafnet.epoch90'), path.join(decaf_folder, 'imagenet.decafnet.meta')) self.feat_layer = 'fc6_cudanet_out' self.classifier = cPickle.load(open(classifer_file, "r")) def predict(self, img): im = img_as_ubyte(color.rgb2gray(img)) scores = self.net.classify(im, center_only=True) feats = self.net.feature(self.feat_layer).flatten() defect_probs = self.classifier.predict_proba(feats) return sorted(zip(self.classifier.classes_, defect_probs[0]), key=lambda (cls, prob): prob, reverse=True) def class_names(self): return self.classifier.classes_
def __init__( self, feature_layer='fc7_cudanet_out', pretrained_params='imagenet.decafnet.epoch90', pretrained_meta='imagenet.decafnet.meta', center_only=True ): """ :param feature_layer: The ConvNet layer that's used for feature extraction. Defaults to `fc7_cudanet_out`. A description of all available layers for the ImageNet-1k-pretrained ConvNet is found in the DeCAF wiki. They are: - `pool5_cudanet_out` - `fc6_cudanet_out` - `fc6_neuron_cudanet_out` - `fc7_cudanet_out` - `fc7_neuron_cudanet_out` :param pretrained_params: This must point to the file with the pretrained parameters. Defaults to `imagenet.decafnet.epoch90`. For the ImageNet-1k-pretrained ConvNet this file can be obtained from here: http://www.eecs.berkeley.edu/~jiayq/decaf_pretrained/ :param pretrained_meta: Similar to `pretrained_params`, this must file to the file with the pretrained parameters' metadata. Defaults to `imagenet.decafnet.meta`. :param center_only: Use the center patch of the image only when extracting features. If `False`, use four corners, the image center and flipped variants and average a total of 10 feature vectors, which will usually yield better results. Defaults to `True`. """ super(ConvNetFeatureExtractor, self).__init__() self.feature_layer = feature_layer self.pretrained_params = pretrained_params self.pretrained_meta = pretrained_meta self.center_only = center_only self.convnet = DecafNet( self.pretrained_params, self.pretrained_meta )
def getPeakFeatures(): net = DecafNet() features = numpy.zeros((number_sequences,feature_length)) labels = numpy.zeros((number_sequences,1)) counter = 0 # Maybe sort them for participant in os.listdir(os.path.join(data_dir,image_dir)): for sequence in os.listdir(os.path.join(data_dir,image_dir, participant)): if sequence != ".DS_Store": image_files = sorted(os.listdir(os.path.join(data_dir,image_dir, participant,sequence))) image_file = image_files[-1] print counter, image_file imarray = cv2.imread(os.path.join(data_dir,image_dir, participant,sequence,image_file)) imarray = cv2.cvtColor(imarray,cv2.COLOR_BGR2GRAY) scores = net.classify(imarray, center_only=True) features[counter] = net.feature(feature_level)#.flatten() label_file = open(os.path.join(data_dir,label_dir, participant,sequence,image_file[:-4]+"_emotion.txt")) labels[counter] = eval(label_file.read()) label_file.close() counter += 1 numpy.save("featuresPeak5",features) numpy.save("labelsPeak5",labels)
def __init__(self, model_spec_filename, model_filename=None,\ wnid_words_filename=None, center_only=False, wnid_subset = []): """ *** PRIVATE CONSTRUCTOR *** """ # the following is just an hack to allow retro-compatibility # with existing code if isinstance(model_spec_filename, NetworkDecafParams): params = model_spec_filename model_spec_filename = params.model_spec_filename model_filename = params.model_filename wnid_words_filename = params.wnid_words_filename center_only = params.center_only wnid_subset = params.wnid_subset if wnid_subset!=[]: print 'Warning: subset of labels not supported yet' else: assert isinstance(model_spec_filename, str) assert model_filename != None assert wnid_words_filename != None # load Decaf model self.net_ = DecafNet(model_filename, model_spec_filename) self.center_only_ = center_only # build a dictionary label --> description self.dict_label_desc_ = {} dict_desc_label = {} fd = open(wnid_words_filename) for line in fd: temp = line.strip().split('\t') wnid = temp[1].strip() self.dict_label_desc_[wnid] = temp[2].strip() dict_desc_label[temp[2].split(',')[0]] = wnid fd.close() # build a dictionary label --> label_id self.dict_label_id_ = {} self.labels_ = [] for i, desc in enumerate(self.net_.label_names): self.dict_label_id_[dict_desc_label[desc]] = i self.labels_.append(dict_desc_label[desc]) # Load the mean vector from file # mean of 3 channels self.net_.mean_img =np.mean(np.mean(self.net_._data_mean,axis=1),axis=0)
def main(): net = DecafNet() video = cv2.VideoCapture(0) cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml') arrays = Queue.LifoQueue() results = Queue.LifoQueue() detector = ComputeFeatures(net, [], arrays, results) detector.daemon = True detector.start() pygame.init() screen = pygame.display.set_mode((width, height)) pygame.display.set_caption('This is a video game') background = pygame.Surface((width, height)) background.fill(white) screen.blit(background, (0, 0)) pygame.display.flip() allsprites = pygame.sprite.RenderUpdates() # Some parameters # size = 10 enemy_surface = pygame.Surface((size, size)) speed = 200.0 playersize = 44 # # # # # # # # # # player = Unit([256.0, 256.0], pygame.Surface((playersize, playersize))) allsprites.add(player) enemy_counter = 1.0 clock = pygame.time.Clock() elapsed = 0.0 accumulator = 0.0 run = True face = None emotion_window = [ "neutral", "neutral", "neutral", "neutral", "neutral", "neutral" ] #emotion_accumulator = 0.0 current_emotion = "neutral" emotion = "neutral" health = 50 game_time = 0.0 while run: seconds = elapsed / 1000.0 accumulator += seconds game_time += seconds #emotion_accumulator += seconds for event in pygame.event.get(): if event.type == pygame.QUIT: run = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: run = False #elif event.type == pygame.KEYDOWN and event.key == pygame.K_w: # current = Unit((random.randint(0,512), random.randint(0,512))) # allsprites.add(current) #elif event.type == pygame.KEYDOWN and event.key == pygame.K_s: # for sprite in allsprites: # sprite.position = [sprite.position[0]+random.randint(-5,5),sprite.position[1]+random.randint(-5,5)] if accumulator > enemy_counter: allsprites.add(Unit([random.randint(0, 512), 0], enemy_surface)) accumulator = 0.0 for sprite in allsprites.sprites(): if sprite.image == enemy_surface: sprite.position[1] += speed * seconds if sprite.position[1] > height - 10: allsprites.remove(sprite) pressed = pygame.key.get_pressed() if pressed[pygame.K_RIGHT]: player.position[0] += speed * seconds if pressed[pygame.K_LEFT]: player.position[0] -= speed * seconds if pressed[pygame.K_DOWN]: player.position[1] += speed * seconds if pressed[pygame.K_UP]: player.position[1] -= speed * seconds allsprites.update() allsprites.remove(player) health -= len(pygame.sprite.spritecollide(player, allsprites, True)) allsprites.add(player) allsprites.clear(screen, background) changed = allsprites.draw(screen) pygame.display.update(changed) frame = video.read()[1] rects = cascade.detectMultiScale(frame, 1.3, 3, cv2.cv.CV_HAAR_SCALE_IMAGE, (150, 150)) #arrays.put(frame) # Idea: increase the size of the rectangle if len(rects) > 0: facerect = rects[0] #facerect[0] -= (rectangle_margin-30) #facerect[2] += rectangle_margin #facerect[1] -= (rectangle_margin-20) #facerect[3] += rectangle_margin face = frame[facerect[1]:facerect[1] + facerect[3], facerect[0]:facerect[0] + facerect[2]] face = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY) arrays.put(face) if True: for (x, y, w, h) in rects: cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2) if not results.empty(): emotion = results.get() emotion_window.append(emotion) emotion_window.pop(0) current_emotion = max(set(emotion_window), key=emotion_window.count) print "Current emotion:", current_emotion, "- Last detected:", emotion #, emotion_window if current_emotion == "happy": enemy_counter += 0.03 enemy_counter = min(0.7, enemy_counter) else: enemy_counter += -0.02 enemy_counter = max(0.01, enemy_counter) print "Health:", health, "- Time:", game_time if health < 1: run = False print "Game over! Score:", game_time if face != None: cv2.imshow("face", face) cv2.imshow("frame", frame) c = cv2.waitKey(1) if c == 27: cv2.destroyWindow("frame") cv2.destroyWindow("face") break elapsed = clock.tick(framerate) video.release() cv2.destroyAllWindows() pygame.quit()
np.save(file_name + '_X.npy', features) np.save(file_name + '_Y.npy', labels) def load_samples(loc_dir="samples"): logging.info("Loading samples from directory (samples)") samples = [] for root, dirs, files in os.walk(loc_dir): for f in files: print f if f[0:8] == "points99": samples.append(("samples/s_negtive/%s"%f, 1)) elif f[0:8] == "points00": samples.append(("samples/s_postive/%s"%f, 2)) else: pass return samples if __name__ == "__main__": """decafnet.""" from decaf.scripts.imagenet import DecafNet logging.getLogger().setLevel(logging.INFO) net = DecafNet() samples_list = load_samples() #extractFeatures(samples_list, net, 'fc6_cudanet_out') #writeFeatures_labels('420_decaf/420_decaf') visualization() joblib.dump({"420_decaf":FEATURES},"420_decaf/420pkl/420.pkl",compress=0) # ѹËõµ¼ÖÂÄÚ´æ²»×ã #import cv2 #print 'prediction:', net.top_k_prediction(scores, 5) #visualize.draw_net_to_file(net._net, 'decafnet.png') #print 'Network structure written to decafnet.png'
class NetworkDecaf(Network): """ Implementation for the Decaf library. """ def __init__(self, model_spec_filename, model_filename=None,\ wnid_words_filename=None, center_only=False, wnid_subset = []): """ *** PRIVATE CONSTRUCTOR *** """ # the following is just an hack to allow retro-compatibility # with existing code if isinstance(model_spec_filename, NetworkDecafParams): params = model_spec_filename model_spec_filename = params.model_spec_filename model_filename = params.model_filename wnid_words_filename = params.wnid_words_filename center_only = params.center_only wnid_subset = params.wnid_subset if wnid_subset!=[]: print 'Warning: subset of labels not supported yet' else: assert isinstance(model_spec_filename, str) assert model_filename != None assert wnid_words_filename != None # load Decaf model self.net_ = DecafNet(model_filename, model_spec_filename) self.center_only_ = center_only # build a dictionary label --> description self.dict_label_desc_ = {} dict_desc_label = {} fd = open(wnid_words_filename) for line in fd: temp = line.strip().split('\t') wnid = temp[1].strip() self.dict_label_desc_[wnid] = temp[2].strip() dict_desc_label[temp[2].split(',')[0]] = wnid fd.close() # build a dictionary label --> label_id self.dict_label_id_ = {} self.labels_ = [] for i, desc in enumerate(self.net_.label_names): self.dict_label_id_[dict_desc_label[desc]] = i self.labels_.append(dict_desc_label[desc]) # Load the mean vector from file # mean of 3 channels self.net_.mean_img =np.mean(np.mean(self.net_._data_mean,axis=1),axis=0) # it is in BGR convert in RGB #self.net_.mean_img = self.net_.mean_img[::-1] def get_mean_img(self): return self.net_.mean_img def get_input_dim(self): return decaf.scripts.imagenet.INPUT_DIM def get_label_id(self, label): return self.dict_label_id_[label] def get_label_desc(self, label): return self.dict_label_desc_[label] def get_labels(self): return self.labels_ def evaluate(self, img, layer_name = 'softmax'): # for now only center_only is supported assert self.center_only_ == True # first, extract the 227x227 center dim = decaf.scripts.imagenet.INPUT_DIM image = util.crop_image_center(decaf.util.transform.as_rgb(img)) image = skimage.transform.resize(image, (dim, dim)) # convert to [0,255] float32 image = image.astype(np.float32) * 255. assert np.max(image) <= 255 # Flip the image if necessary, maintaining the c_contiguous order if decaf.scripts.imagenet._JEFFNET_FLIP: image = image[::-1, :].copy() # subtract the mean, cropping the 256x256 mean image xoff = (self.net_._data_mean.shape[1] - dim)/2 yoff = (self.net_._data_mean.shape[0] - dim)/2 image -= self.net_._data_mean[yoff+yoff+dim, xoff:xoff+dim] # make sure the data in contiguous in memory images = np.ascontiguousarray(image[np.newaxis], dtype=np.float32) # classify predictions = self.net_.classify_direct(images) scores = predictions.mean(0) # look at the particular layer if layer_name == 'softmax': return scores elif layer_name == 'fc7_relu': layer_name = 'fc7_neuron_cudanet_out' elif layer_name == 'fc7': layer_name = 'fc7_cudanet_out' elif layer_name == 'fc6_relu': layer_name = 'fc6_neuron_cudanet_out' elif layer_name == 'fc6': layer_name = 'fc6_cudanet_out' elif layer_name == 'pool5': layer_name = 'pool5_cudanet_out' else: raise ValueError('layer_name not supported') return self.net_.feature(layer_name)
from classify.ttypes import * # Thrift files from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from thrift.server import TServer #******************************************* import sys sys.path.append("decaf") from decaf.scripts.imagenet import DecafNet import cStringIO as StringIO import Image import numpy as np net = DecafNet('imagenet.decafnet.epoch90', 'imagenet.decafnet.meta') from time import time as tic #******************************************** # Server implementation class ClassifyHandler: ## return current time stamp #def showCurrentTimestamp(self): # timeStamp = time.time() # return str(timeStamp) ## print something to string, wait 10 secs, than print something again #def asynchronousJob(self): # print 'Assume that this work takes 10 seconds'
#!/usr/bin/python import sys sys.path.append("decaf") from decaf.scripts.imagenet import DecafNet import cStringIO as StringIO import Image import numpy as np from time import time as tic net = DecafNet('imagenet.decafnet.epoch90', 'imagenet.decafnet.meta') start_time = tic() #img = np.asarray(Image.open("cat.jpg")) img_content = open("cat.jpg").read() print len(img_content) stream = StringIO.StringIO(img_content) img = np.asarray(Image.open(stream)) scores = net.classify(img) print net.top_k_prediction(scores, 5) #scores = net.classify(img, center_only=True) end_time = tic() print "diff_time: %f" % (end_time - start_time)
from sklearn.base import TransformerMixin from skimage.io import imread import numpy as np #import operator import logging logging.getLogger().setLevel(logging.ERROR) from PIL import Image img_size = (256,256,3) def resize(img): tmp = Image.fromarray(img) tmp = tmp.resize(img_size[0:2]) return np.array(tmp) from decaf.scripts.imagenet import DecafNet NET = DecafNet() class DecafFeature(TransformerMixin): """ Extract Decaf Feature Parameters ---------- layer_name : str Decaf layer name, default:fc6_cudanet_out img_size : tuple the size of X, default: (256, 256, 3) """ def __init__(self, layer='fc6_cudanet_out', img_size=(256, 256, 3)):
class DecafExtractor: def __init__(self, layer_name, model_path = 'dist/decaf-release/model/imagenet.decafnet.epoch90', meta_path = 'dist/decaf-release/model/imagenet.decafnet.meta'): self.layer_name = layer_name self.net = DecafNet(model_path, meta_path) self.transforms = [NopTransform()] def set_parameters(self, patch_size, patches_per_image, levels, image_dim, decaf_oversample=False): self.patch_size = patch_size self.patches_per_image = patches_per_image self.levels = levels self.image_dim = image_dim self.decaf_oversample = decaf_oversample self.patch_sizes = map(int, self.patch_size * 2**np.arange(0,levels,1.0)) def add_transform(self, transform): self.transforms.append(transform) def get_descriptor_size(self): if self.layer_name in ['67_relu', '67']: return 8192 else: return 4096 def get_decaf(self, im): scores = self.net.classify(np.asarray(im), center_only=not self.decaf_oversample) if self.layer_name == '67_relu': return np.hstack([self.net.feature('fc6_neuron_cudanet_out'), self.net.feature('fc7_neuron_cudanet_out')]) elif self.layer_name == '67': return np.hstack([self.net.feature('fc6_cudanet_out'), self.net.feature('fc7_cudanet_out')]) else: return self.net.feature(self.layer_name) def get_number_of_features_per_image(self): if self.decaf_oversample: return 10*len(self.transforms) else: return len(self.transforms) def extract_image(self, filename): """ This method extracts 4096-dimensional DeCAF features from patches at multiple scales belonging to the the image file <filename>. Number of scales, patch size, and other settings are set by method set_parameters(). This method returns tuple (patches, positions, patch_number), where <patches> is a numpy array of dimension (patch_number, 4096) holding features, <positions> is a numpy array of dimension (patch_number, 2) holding absolute positions of patches, <patch_number> is the number of patches that algorithm managed to extract -- it is guaranteed to be at most the number of originally specified. """ log = get_logger() im = Image.open(filename) # Resizing image if max(im.size) != self.image_dim: if im.size[0] > im.size[1]: new_height = (self.image_dim * im.size[1]) / im.size[0] new_dim = (self.image_dim, new_height) else: new_width = (self.image_dim * im.size[0]) / im.size[1] new_dim = (new_width, self.image_dim) log.info('Resizing image from (%d, %d) to (%d, %d).', im.size[0], im.size[1], new_dim[0], new_dim[1]) im = im.resize(new_dim, Image.ANTIALIAS) # Estimating number of extracted features taking into account transformations estimated_feature_num = self.patches_per_image * self.get_number_of_features_per_image() # Provisioning space for patches and locations feature_storage = ExtractedFeatures(estimated_feature_num, self.get_descriptor_size()) log.info('Extracting up to %d patches at %d levels from "%s"...', self.patches_per_image * self.get_number_of_features_per_image(), self.levels, basename(filename)) # Applying transformations and extracting features for xform in self.transforms: im_ = xform.apply(im) self.extract(im_, feature_storage, xform.check_coords, xform, filename) log.info('Done. Extracted: %d.', feature_storage.cursor) return feature_storage def extract(self, im, feature_storage, check_patch_coords, transform, filename): (w, h) = im.size # Calculating patch step if self.levels > 0: patch_step = int( (w*h * len(self.patch_sizes) / self.patches_per_image)**0.5 ) w_steps = np.arange(0, w, patch_step) h_steps = np.arange(0, h, patch_step) (xx, yy) = np.meshgrid(w_steps, h_steps) if isinstance(transform, NopTransform): # Hacky.... # Extracting features for the whole image feature_storage.append( self.get_decaf(im), np.matrix([0,0]) ) # Extracting features from patches for l in range(self.levels): for i in range(xx.shape[0]): for j in range(xx.shape[1]): x = xx[i,j] y = yy[i,j] patch_left = x+self.patch_sizes[l] patch_bottom = y+self.patch_sizes[l] if (check_patch_coords(x, y, patch_left, patch_bottom) and patch_left <= w and patch_bottom <= h ): patch = im.crop( (x, y, patch_left, patch_bottom) ) patch.load() feature_storage.append( self.get_decaf(patch), np.matrix([x, y]) )
class ConvNetFeatures(BaseEstimator): """Extract features from images using a pretrained ConvNet. Based on Yangqing Jia and Jeff Donahue's `DeCAF <https://github.com/UCB-ICSI-Vision-Group/decaf-release/wiki>`_. Please make sure you read and accept DeCAF's license before you use this class. If ``classify_direct=False``, expects its input X to be a list of image filenames or arrays as produced by `np.array(Image.open(filename))`. """ verbose = 0 def __init__( self, feature_layer='fc7_cudanet_out', pretrained_params='imagenet.decafnet.epoch90', pretrained_meta='imagenet.decafnet.meta', center_only=True, classify_direct=False, verbose=0, ): """ :param feature_layer: The ConvNet layer that's used for feature extraction. Defaults to `fc7_cudanet_out`. A description of all available layers for the ImageNet-1k-pretrained ConvNet is found in the DeCAF wiki. They are: - `pool5_cudanet_out` - `fc6_cudanet_out` - `fc6_neuron_cudanet_out` - `fc7_cudanet_out` - `fc7_neuron_cudanet_out` - `probs_cudanet_out` :param pretrained_params: This must point to the file with the pretrained parameters. Defaults to `imagenet.decafnet.epoch90`. For the ImageNet-1k-pretrained ConvNet this file can be obtained from here: http://www.eecs.berkeley.edu/~jiayq/decaf_pretrained/ :param pretrained_meta: Similar to `pretrained_params`, this must file to the file with the pretrained parameters' metadata. Defaults to `imagenet.decafnet.meta`. :param center_only: Use the center patch of the image only when extracting features. If `False`, use four corners, the image center and flipped variants and average a total of 10 feature vectors, which will usually yield better results. Defaults to `True`. :param classify_direct: When `True`, assume that input X is an array of shape (num x 256 x 256 x 3) as returned by `prepare_image`. """ self.feature_layer = feature_layer self.pretrained_params = pretrained_params self.pretrained_meta = pretrained_meta self.center_only = center_only self.classify_direct = classify_direct self.net_ = None if (not os.path.exists(pretrained_params) or not os.path.exists(pretrained_meta)): raise ValueError( "Pre-trained ConvNet parameters not found. You may" "need to download the files from " "http://www.eecs.berkeley.edu/~jiayq/decaf_pretrained/ and " "pass the path to the two files as `pretrained_params` and " "`pretrained_meta` to the `{}` estimator.".format( self.__class__.__name__)) def fit(self, X=None, y=None): from decaf.scripts.imagenet import DecafNet # soft dep if self.net_ is None: self.net_ = DecafNet( self.pretrained_params, self.pretrained_meta, ) return self @cache.cached(_transform_cache_key) def transform(self, X): features = [] for img in X: if self.classify_direct: images = self.net_.oversample( img, center_only=self.center_only) self.net_.classify_direct(images) else: if isinstance(img, str): import Image # soft dep img = np.array(Image.open(img)) self.net_.classify(img, center_only=self.center_only) feat = None for layer in self.feature_layer.split(','): val = self.net_.feature(layer) if feat is None: feat = val else: feat = np.hstack([feat, val]) if not self.center_only: feat = feat.flatten() features.append(feat) if self.verbose: sys.stdout.write( "\r[ConvNet] %d%%" % (100. * len(features) / len(X))) sys.stdout.flush() if self.verbose: sys.stdout.write('\n') return np.vstack(features) def prepare_image(self, image): """Returns image of shape `(256, 256, 3)`, as expected by `transform` when `classify_direct = True`. """ from decaf.util import transform # soft dep _JEFFNET_FLIP = True # first, extract the 256x256 center. image = transform.scale_and_extract(transform.as_rgb(image), 256) # convert to [0,255] float32 image = image.astype(np.float32) * 255. if _JEFFNET_FLIP: # Flip the image if necessary, maintaining the c_contiguous order image = image[::-1, :].copy() # subtract the mean image -= self.net_._data_mean return image
new_shape = (int(k * w), int(k * h)) resized = transform.resize(readed, new_shape) else: resized = readed return resized, np.asarray(resized) if __name__ == '__main__': folder = sys.argv[1] out_folder = sys.argv[2] if os.path.exists(out_folder): shutil.rmtree(out_folder) os.mkdir(out_folder) imgs = glob.glob(os.path.join(folder,"*.jpeg")) print imgs net = DecafNet('../imagenet_pretrained/imagenet.decafnet.epoch90', '../imagenet_pretrained/imagenet.decafnet.meta') flog = open('log.txt', 'w') for i, imgname in enumerate(imgs): flog.write("%s\t%d" % (imgname, i)) try: resized, img = load_and_resize(imgname) except ValueError: print "error when read %s" % imgname continue scores = net.classify(img, center_only=True) feature = net.feature('fc6_cudanet_out') print feature out_file = open(os.path.join(out_folder, "%d.npy" % i), 'w')
def __init__(self, layer_name, model_path = 'dist/decaf-release/model/imagenet.decafnet.epoch90', meta_path = 'dist/decaf-release/model/imagenet.decafnet.meta'): self.layer_name = layer_name self.net = DecafNet(model_path, meta_path) self.transforms = [NopTransform()]
from decaf.scripts.imagenet import DecafNet from skimage import io import numpy as np import scipy.io as sio import os import sys if len(sys.argv) != 5: print "Usage ", sys.argv[0], "<model_root_dir> <image_dir> <output_feature_path> <num_imgs>" exit(1) model_root = sys.argv[1] net = DecafNet(model_root + 'imagenet.decafnet.epoch90', model_root + 'imagenet.decafnet.meta') img_dir = sys.argv[2] feature_path = sys.argv[3] NUM_IMGS = int(sys.argv[4]) FEATURE_DIM = 4096 #fc6_cudanet_out's dimension features = np.zeros((NUM_IMGS,FEATURE_DIM)) for i in range(NUM_IMGS): filename = img_dir + "/%05d.jpg" %(i+1) if os.path.exists(filename): sys.stdout.write("Extracting DeCAF feature from image %d\n" %(i+1)) img = io.imread(filename) net.classify(img, center_only=True) features[i,:] = net.feature('fc6_cudanet_out') sio.savemat(feature_path,{'features':features})
try: return img_as_ubyte(resize(img, (256,256), mode='wrap')) # resize 后是float64 except: #保存检测过程图像 io.imsave("420_decaf/tmp/%s_%s_%s_%s.png" % \ (lu_offset_x, lu_offset_y, w, h), img) tmp = cv2.imread("420_decaf/tmp/%s_%s_%s_%s.png" % \ (lu_offset_x, lu_offset_y, w, h)) return cv2.resize(img, (256,256), interpolation=cv2.INTER_LINEAR) #return resize(img, (256,256)) # 加载 decaf 和 classifier from decaf.scripts.imagenet import DecafNet net = DecafNet() clf = joblib.load("420_decaf/classifier_svc.pkl") blob_name='fc6_cudanet_out' # 命令行参数情况 if len(sys.argv) < 3: print "usage: object_classify.py path_to_image path_to_segmentation_folder..." sys.exit() else: img_path = sys.argv[1] segmentation_folder = sys.argv[2:] # 读取栅格图像 g_raster = gdal.Open(img_path) # 与分割文件对应的原始栅格 # 读取分割结果 shp 文件
class NetworkDecaf(Network): """ Implementation for the Decaf library. """ def __init__(self, model_spec_filename, model_filename=None,\ wnid_words_filename=None, center_only=False, wnid_subset = []): """ *** PRIVATE CONSTRUCTOR *** """ # the following is just an hack to allow retro-compatibility # with existing code if isinstance(model_spec_filename, NetworkDecafParams): params = model_spec_filename model_spec_filename = params.model_spec_filename model_filename = params.model_filename wnid_words_filename = params.wnid_words_filename center_only = params.center_only wnid_subset = params.wnid_subset if wnid_subset != []: print 'Warning: subset of labels not supported yet' else: assert isinstance(model_spec_filename, str) assert model_filename != None assert wnid_words_filename != None # load Decaf model self.net_ = DecafNet(model_filename, model_spec_filename) self.center_only_ = center_only # build a dictionary label --> description self.dict_label_desc_ = {} dict_desc_label = {} fd = open(wnid_words_filename) for line in fd: temp = line.strip().split('\t') wnid = temp[1].strip() self.dict_label_desc_[wnid] = temp[2].strip() dict_desc_label[temp[2].split(',')[0]] = wnid fd.close() # build a dictionary label --> label_id self.dict_label_id_ = {} self.labels_ = [] for i, desc in enumerate(self.net_.label_names): self.dict_label_id_[dict_desc_label[desc]] = i self.labels_.append(dict_desc_label[desc]) # Load the mean vector from file # mean of 3 channels self.net_.mean_img = np.mean(np.mean(self.net_._data_mean, axis=1), axis=0) # it is in BGR convert in RGB #self.net_.mean_img = self.net_.mean_img[::-1] def get_mean_img(self): return self.net_.mean_img def get_input_dim(self): return decaf.scripts.imagenet.INPUT_DIM def get_label_id(self, label): return self.dict_label_id_[label] def get_label_desc(self, label): return self.dict_label_desc_[label] def get_labels(self): return self.labels_ def evaluate(self, img, layer_name='softmax'): # for now only center_only is supported assert self.center_only_ == True # first, extract the 227x227 center dim = decaf.scripts.imagenet.INPUT_DIM image = util.crop_image_center(decaf.util.transform.as_rgb(img)) image = skimage.transform.resize(image, (dim, dim)) # convert to [0,255] float32 image = image.astype(np.float32) * 255. assert np.max(image) <= 255 # Flip the image if necessary, maintaining the c_contiguous order if decaf.scripts.imagenet._JEFFNET_FLIP: image = image[::-1, :].copy() # subtract the mean, cropping the 256x256 mean image xoff = (self.net_._data_mean.shape[1] - dim) / 2 yoff = (self.net_._data_mean.shape[0] - dim) / 2 image -= self.net_._data_mean[yoff + yoff + dim, xoff:xoff + dim] # make sure the data in contiguous in memory images = np.ascontiguousarray(image[np.newaxis], dtype=np.float32) # classify predictions = self.net_.classify_direct(images) scores = predictions.mean(0) # look at the particular layer if layer_name == 'softmax': return scores elif layer_name == 'fc7_relu': layer_name = 'fc7_neuron_cudanet_out' elif layer_name == 'fc7': layer_name = 'fc7_cudanet_out' elif layer_name == 'fc6_relu': layer_name = 'fc6_neuron_cudanet_out' elif layer_name == 'fc6': layer_name = 'fc6_cudanet_out' elif layer_name == 'pool5': layer_name = 'pool5_cudanet_out' else: raise ValueError('layer_name not supported') return self.net_.feature(layer_name)
from decaf.scripts.imagenet import DecafNet import numpy, scipy, PIL, csv, glob import numpy as np from PIL import Image from sklearn.decomposition import PCA import os import cv2, scipy import pickle from mlabwrap import mlab ucfloc = 'decaf/KitchenData/' imgnetPath = 'decaf/imagenet_pretrained/' flowdir = 'flowdata/' net = DecafNet(imgnetPath + 'imagenet.decafnet.epoch90', imgnetPath + 'imagenet.decafnet.meta') pca = PCA(n_components=20) class Feature(): def __init__(self, decaf, category, _id): self.decaf = decaf self.category = category self.path = _id def imToNumpy(img): return numpy.asarray(PIL.Image.open(img)) def getFeature(img):
class DecafExtractor: def __init__( self, layer_name, model_path='dist/decaf-release/model/imagenet.decafnet.epoch90', meta_path='dist/decaf-release/model/imagenet.decafnet.meta'): self.layer_name = layer_name self.net = DecafNet(model_path, meta_path) self.transforms = [NopTransform()] def set_parameters(self, patch_size, patches_per_image, levels, image_dim, decaf_oversample=False): self.patch_size = patch_size self.patches_per_image = patches_per_image self.levels = levels self.image_dim = image_dim self.decaf_oversample = decaf_oversample self.patch_sizes = map(int, self.patch_size * 2**np.arange(0, levels, 1.0)) def add_transform(self, transform): self.transforms.append(transform) def get_descriptor_size(self): if self.layer_name in ['67_relu', '67']: return 8192 else: return 4096 def get_decaf(self, im): scores = self.net.classify(np.asarray(im), center_only=not self.decaf_oversample) if self.layer_name == '67_relu': return np.hstack([ self.net.feature('fc6_neuron_cudanet_out'), self.net.feature('fc7_neuron_cudanet_out') ]) elif self.layer_name == '67': return np.hstack([ self.net.feature('fc6_cudanet_out'), self.net.feature('fc7_cudanet_out') ]) else: return self.net.feature(self.layer_name) def get_number_of_features_per_image(self): if self.decaf_oversample: return 10 * len(self.transforms) else: return len(self.transforms) def extract_image(self, filename): """ This method extracts 4096-dimensional DeCAF features from patches at multiple scales belonging to the the image file <filename>. Number of scales, patch size, and other settings are set by method set_parameters(). This method returns tuple (patches, positions, patch_number), where <patches> is a numpy array of dimension (patch_number, 4096) holding features, <positions> is a numpy array of dimension (patch_number, 2) holding absolute positions of patches, <patch_number> is the number of patches that algorithm managed to extract -- it is guaranteed to be at most the number of originally specified. """ log = get_logger() im = Image.open(filename) # Resizing image if max(im.size) != self.image_dim: if im.size[0] > im.size[1]: new_height = (self.image_dim * im.size[1]) / im.size[0] new_dim = (self.image_dim, new_height) else: new_width = (self.image_dim * im.size[0]) / im.size[1] new_dim = (new_width, self.image_dim) log.info('Resizing image from (%d, %d) to (%d, %d).', im.size[0], im.size[1], new_dim[0], new_dim[1]) im = im.resize(new_dim, Image.ANTIALIAS) # Estimating number of extracted features taking into account transformations estimated_feature_num = self.patches_per_image * self.get_number_of_features_per_image( ) # Provisioning space for patches and locations feature_storage = ExtractedFeatures(estimated_feature_num, self.get_descriptor_size()) log.info( 'Extracting up to %d patches at %d levels from "%s"...', self.patches_per_image * self.get_number_of_features_per_image(), self.levels, basename(filename)) # Applying transformations and extracting features for xform in self.transforms: im_ = xform.apply(im) self.extract(im_, feature_storage, xform.check_coords, xform, filename) log.info('Done. Extracted: %d.', feature_storage.cursor) return feature_storage def extract(self, im, feature_storage, check_patch_coords, transform, filename): (w, h) = im.size # Calculating patch step if self.levels > 0: patch_step = int( (w * h * len(self.patch_sizes) / self.patches_per_image)**0.5) w_steps = np.arange(0, w, patch_step) h_steps = np.arange(0, h, patch_step) (xx, yy) = np.meshgrid(w_steps, h_steps) if isinstance(transform, NopTransform): # Hacky.... # Extracting features for the whole image feature_storage.append(self.get_decaf(im), np.matrix([0, 0])) # Extracting features from patches for l in range(self.levels): for i in range(xx.shape[0]): for j in range(xx.shape[1]): x = xx[i, j] y = yy[i, j] patch_left = x + self.patch_sizes[l] patch_bottom = y + self.patch_sizes[l] if (check_patch_coords(x, y, patch_left, patch_bottom) and patch_left <= w and patch_bottom <= h): patch = im.crop((x, y, patch_left, patch_bottom)) patch.load() feature_storage.append(self.get_decaf(patch), np.matrix([x, y]))