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 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 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 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)
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 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 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)
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
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})
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]))
numFeatures = layer.GetFeatureCount() print 'Total region count:', numFeatures #test img = None TEST = False if TEST == True: feature = layer.GetNextFeature() img = getRegion(g_raster, feature) # show #print img.dtype #plt.figure() #plt.imshow(img) net.classify(img, True) tmp = net.feature(blob_name) #与训练时候保持一致 is_slide = clf.predict(tmp) feature.SetField("slide", is_slide[0]) else: # loop through the regions and predict them pbar = progressbar.ProgressBar(maxval=numFeatures).start() cnt = 0 feature = layer.GetNextFeature() while feature: # 获取对应的图像样本 img = getRegion(g_raster, feature) #imshow(img) #raw_input()
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') np.save(out_file, feature) io.imsave(os.path.join(out_folder, "%d.jpg" % i), resized)
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]) )
#!/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)