def experiment_nnFullImage(params):
    
    if params.out_file_pickle is None:
        out_file_pickle,out_file_text=setupFilesWithBigObjectForFeatureExtraction(params.db_path,params.class_id,params.threshold,params.out_file_pre,params.path_to_annotation,params.path_to_images)
        params=params._replace(out_file_pickle=out_file_pickle)
        params=params._replace(out_file_text=out_file_text)
    
    out_file_pickle=params.out_file_pickle;
    out_file_text=params.out_file_text;
    print out_file_pickle
    [img_paths_originals,img_paths_to_keep,class_id_idx_tuples]=pickle.load(open(out_file_pickle,'rb'));
    assert len(img_paths_originals)==len(class_id_idx_tuples)

    file_names_mat,object_indices=recreateOriginalPaths(params.path_to_annotation,img_paths_to_keep,returnObject_idx=True);
    print 'getting azimuths'
    azimuths=[getObjectStruct(file_name,object_idx).viewpoint.azimuth_coarse  for file_name,object_idx in zip(file_names_mat,object_indices)]
    
    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers=caffe_wrapper.saveFeaturesOfLayers(out_file_text,params.path_to_classify,params.gpu_no,params.layers,ext='jpg',out_file=params.out_file_pre,meanFile=params.caffe_mean,deployFile=params.caffe_deploy,modelFile=params.caffe_model)
        params=params._replace(out_file_layers=out_file_layers)
        
    out_file_layers=params.out_file_layers;

    print 'writing to db'
    for layer in params.layers:
        vals=np.load(out_file_layers);
        indices,distances=nearest_neighbor.doCosineDistanceNN(vals[layer],numberOfN=None);
        mani=Pascal3D_Manipulator(params.db_path_out);
        mani.openSession();
        for idx in range(len(img_paths_originals)):
            mani.insert(idx,img_paths_originals[idx],layer,out_file_layers,class_id_idx_tuples[idx][0],class_id_idx_tuples[idx][1],params.caffe_model, azimuth=azimuths[idx],neighbor_index=indices[idx],neighbor_distance=distances[idx],trainedClass=params.trainFlag)
        mani.closeSession();
    
    return params
def experiment_nnPatches(params):
    out_file_text=params.out_file_text;
    class_ids=params.class_id;

    img_paths=util.readLinesFromFile(out_file_text)
    class_id_idx_tuples=[];
    for img_path in img_paths:
        class_id=img_path[:img_path.rindex('_')]
        class_id=class_id[class_id.rindex('_')+1:];
        class_idx=class_ids.index(class_id);
        class_idx=params.class_idx[class_idx];
        class_id_idx_tuples.append((class_id,class_idx));

    file_names_mat,object_indices=recreateOriginalPaths(params.path_to_annotation,img_paths,returnObject_idx=True);
    print 'getting azimuths'
    azimuths=[getObjectStruct(file_name,object_idx).viewpoint.azimuth_coarse  for file_name,object_idx in zip(file_names_mat,object_indices)]
    
    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers=caffe_wrapper.saveFeaturesOfLayers(out_file_text,params.path_to_classify,params.gpu_no,params.layers,ext='jpg',out_file=params.out_file_pre,meanFile=params.caffe_mean,deployFile=params.caffe_deploy,modelFile=params.caffe_model,images_dim=params.images_dim)
        params=params._replace(out_file_layers=out_file_layers)
        
    out_file_layers=params.out_file_layers;

    print 'writing to db'
    for layer in params.layers:
        vals=np.load(out_file_layers);
        indices,distances=nearest_neighbor.doCosineDistanceNN(vals[layer],numberOfN=None);
        mani=Pascal3D_Manipulator(params.db_path_out);
        mani.openSession();
        for idx in range(len(img_paths)):
            mani.insert(idx,img_paths[idx],layer,out_file_layers,class_id_idx_tuples[idx][0],class_id_idx_tuples[idx][1],params.caffe_model, azimuth=azimuths[idx],neighbor_index=indices[idx],neighbor_distance=distances[idx],trainedClass=params.trainFlag,commitFlag=False)
        mani.closeSession();

    return params
def experiment_nnFullImageMixWithImagenet(params):
    
    if params.out_file_text is None:
        all_files_info=preprocessImagesFromImagenet(params.imagenet_ids_to_test,params.synset_words,params.val_gt_file,path_to_images_imagenet=params.path_to_images_imagenet)
        all_files_info=getImageInfoForMixTestFromPascal3d(params.db_path_in,params.class_id_pascal,all_files_info=all_files_info);
        out_file_pickle=params.out_file_pre+'.p';
        out_file_text=params.out_file_pre+'.txt';
        pickle.dump(all_files_info,open(out_file_pickle,'wb'));
        with open(out_file_text,'wb') as f:
            for dict_curr in all_files_info:
                f.write(dict_curr['img_path']+'\n');
        params=params._replace(out_file_pickle=out_file_pickle)
        params=params._replace(out_file_text=out_file_text)

    out_file_text=params.out_file_text;
    out_file_pickle=params.out_file_pickle;
    
    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers=caffe_wrapper.saveFeaturesOfLayers(out_file_text,params.path_to_classify,params.gpu_no,params.layers,ext=params.ext,out_file=params.out_file_pre,meanFile=params.caffe_mean,deployFile=params.caffe_deploy,modelFile=params.caffe_model)
        params=params._replace(out_file_layers=out_file_layers)
        
    out_file_layers=params.out_file_layers;
    all_files_info=pickle.load(open(out_file_pickle,'rb'));

    print 'writing to db'
    for layer in params.layers:
        vals=np.load(out_file_layers);
        indices,distances=nearest_neighbor.doCosineDistanceNN(vals[layer],numberOfN=None);
        mani=Pascal3D_Manipulator(params.db_path_out);
        mani.openSession();
        # for idx in range(len(img_paths_originals)):
        for idx,dict_curr in enumerate(all_files_info):
            mani.insert(idx,dict_curr['img_path'],layer,out_file_layers,dict_curr['class_id'],dict_curr['class_idx'],params.caffe_model, azimuth=dict_curr['azimuth'],neighbor_index=indices[idx],neighbor_distance=distances[idx],trainedClass=params.trainFlag)
        mani.closeSession();
    
    return params;
def experiment_nnFullImage(params):

    if params.out_file_pickle is None:
        out_file_pickle, out_file_text = setupFilesWithBigObjectForFeatureExtraction(
            params.db_path, params.class_id, params.threshold,
            params.out_file_pre, params.path_to_annotation,
            params.path_to_images)
        params = params._replace(out_file_pickle=out_file_pickle)
        params = params._replace(out_file_text=out_file_text)

    out_file_pickle = params.out_file_pickle
    out_file_text = params.out_file_text
    print out_file_pickle
    [img_paths_originals, img_paths_to_keep,
     class_id_idx_tuples] = pickle.load(open(out_file_pickle, 'rb'))
    assert len(img_paths_originals) == len(class_id_idx_tuples)

    file_names_mat, object_indices = recreateOriginalPaths(
        params.path_to_annotation, img_paths_to_keep, returnObject_idx=True)
    print 'getting azimuths'
    azimuths = [
        getObjectStruct(file_name, object_idx).viewpoint.azimuth_coarse
        for file_name, object_idx in zip(file_names_mat, object_indices)
    ]

    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers = caffe_wrapper.saveFeaturesOfLayers(
            out_file_text,
            params.path_to_classify,
            params.gpu_no,
            params.layers,
            ext='jpg',
            out_file=params.out_file_pre,
            meanFile=params.caffe_mean,
            deployFile=params.caffe_deploy,
            modelFile=params.caffe_model)
        params = params._replace(out_file_layers=out_file_layers)

    out_file_layers = params.out_file_layers

    print 'writing to db'
    for layer in params.layers:
        vals = np.load(out_file_layers)
        indices, distances = nearest_neighbor.doCosineDistanceNN(
            vals[layer], numberOfN=None)
        mani = Pascal3D_Manipulator(params.db_path_out)
        mani.openSession()
        for idx in range(len(img_paths_originals)):
            mani.insert(idx,
                        img_paths_originals[idx],
                        layer,
                        out_file_layers,
                        class_id_idx_tuples[idx][0],
                        class_id_idx_tuples[idx][1],
                        params.caffe_model,
                        azimuth=azimuths[idx],
                        neighbor_index=indices[idx],
                        neighbor_distance=distances[idx],
                        trainedClass=params.trainFlag)
        mani.closeSession()

    return params
def experiment_nnPatches(params):
    out_file_text = params.out_file_text
    class_ids = params.class_id

    img_paths = util.readLinesFromFile(out_file_text)
    class_id_idx_tuples = []
    for img_path in img_paths:
        class_id = img_path[:img_path.rindex('_')]
        class_id = class_id[class_id.rindex('_') + 1:]
        class_idx = class_ids.index(class_id)
        class_idx = params.class_idx[class_idx]
        class_id_idx_tuples.append((class_id, class_idx))

    file_names_mat, object_indices = recreateOriginalPaths(
        params.path_to_annotation, img_paths, returnObject_idx=True)
    print 'getting azimuths'
    azimuths = [
        getObjectStruct(file_name, object_idx).viewpoint.azimuth_coarse
        for file_name, object_idx in zip(file_names_mat, object_indices)
    ]

    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers = caffe_wrapper.saveFeaturesOfLayers(
            out_file_text,
            params.path_to_classify,
            params.gpu_no,
            params.layers,
            ext='jpg',
            out_file=params.out_file_pre,
            meanFile=params.caffe_mean,
            deployFile=params.caffe_deploy,
            modelFile=params.caffe_model,
            images_dim=params.images_dim)
        params = params._replace(out_file_layers=out_file_layers)

    out_file_layers = params.out_file_layers

    print 'writing to db'
    for layer in params.layers:
        vals = np.load(out_file_layers)
        indices, distances = nearest_neighbor.doCosineDistanceNN(
            vals[layer], numberOfN=None)
        mani = Pascal3D_Manipulator(params.db_path_out)
        mani.openSession()
        for idx in range(len(img_paths)):
            mani.insert(idx,
                        img_paths[idx],
                        layer,
                        out_file_layers,
                        class_id_idx_tuples[idx][0],
                        class_id_idx_tuples[idx][1],
                        params.caffe_model,
                        azimuth=azimuths[idx],
                        neighbor_index=indices[idx],
                        neighbor_distance=distances[idx],
                        trainedClass=params.trainFlag,
                        commitFlag=False)
        mani.closeSession()

    return params
def experiment_nnFullImageMixWithImagenet(params):

    if params.out_file_text is None:
        all_files_info = preprocessImagesFromImagenet(
            params.imagenet_ids_to_test,
            params.synset_words,
            params.val_gt_file,
            path_to_images_imagenet=params.path_to_images_imagenet)
        all_files_info = getImageInfoForMixTestFromPascal3d(
            params.db_path_in,
            params.class_id_pascal,
            all_files_info=all_files_info)
        out_file_pickle = params.out_file_pre + '.p'
        out_file_text = params.out_file_pre + '.txt'
        pickle.dump(all_files_info, open(out_file_pickle, 'wb'))
        with open(out_file_text, 'wb') as f:
            for dict_curr in all_files_info:
                f.write(dict_curr['img_path'] + '\n')
        params = params._replace(out_file_pickle=out_file_pickle)
        params = params._replace(out_file_text=out_file_text)

    out_file_text = params.out_file_text
    out_file_pickle = params.out_file_pickle

    if params.out_file_layers is None:
        print 'running layers part'
        out_file_layers = caffe_wrapper.saveFeaturesOfLayers(
            out_file_text,
            params.path_to_classify,
            params.gpu_no,
            params.layers,
            ext=params.ext,
            out_file=params.out_file_pre,
            meanFile=params.caffe_mean,
            deployFile=params.caffe_deploy,
            modelFile=params.caffe_model)
        params = params._replace(out_file_layers=out_file_layers)

    out_file_layers = params.out_file_layers
    all_files_info = pickle.load(open(out_file_pickle, 'rb'))

    print 'writing to db'
    for layer in params.layers:
        vals = np.load(out_file_layers)
        indices, distances = nearest_neighbor.doCosineDistanceNN(
            vals[layer], numberOfN=None)
        mani = Pascal3D_Manipulator(params.db_path_out)
        mani.openSession()
        # for idx in range(len(img_paths_originals)):
        for idx, dict_curr in enumerate(all_files_info):
            mani.insert(idx,
                        dict_curr['img_path'],
                        layer,
                        out_file_layers,
                        dict_curr['class_id'],
                        dict_curr['class_idx'],
                        params.caffe_model,
                        azimuth=dict_curr['azimuth'],
                        neighbor_index=indices[idx],
                        neighbor_distance=distances[idx],
                        trainedClass=params.trainFlag)
        mani.closeSession()

    return params
def script_temp():

    path_to_val = "/disk2/imagenet/val"
    ext = "JPEG"

    out_dir = "/disk2/novemberExperiments/nn_imagenet_try"
    if not os.path.exists(out_dir):
        os.mkdir(out_dir)

    in_file_pre = "list_of_ims_for_nn"
    in_file_pre = os.path.join(out_dir, in_file_pre)

    path_to_classify = ".."
    trainFlag = False
    # caffe_model='/home/maheenrashid/Downloads/caffe/caffe-rc2/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel';
    caffe_model = "/disk2/octoberExperiments/nn_performance_without_pascal/snapshot_iter_450000.caffemodel"
    caffe_deploy = "/disk2/octoberExperiments/nn_performance_without_pascal/deploy.prototxt"
    caffe_mean = "/disk2/octoberExperiments/nn_performance_without_pascal/mean.npy"
    gpu_no = 0
    layers = ["pool5", "fc6", "fc7"]
    out_file = "nn_non_trained"
    out_file = os.path.join(out_dir, out_file)

    db_path_out = "sqlite://///disk2/novemberExperiments/nn_imagenet/nn_imagenet.db"

    synset_words = "../../data/ilsvrc12/synset_words.txt"
    val_gt_file = "../../data/ilsvrc12/val.txt"

    idx_chosen = pickle.load(open("/disk2/novemberExperiments/nn_imagenet/equal_mix_ids.p", "rb"))

    im_files_gt_classes = imagenet.selectTestSetByID(val_gt_file, idx_chosen, path_to_val=path_to_val)
    im_files = list(zip(*im_files_gt_classes)[0])
    gt_classes = list(zip(*im_files_gt_classes)[1])
    print len(im_files)
    print len(gt_classes)
    print len(set(gt_classes))
    per_file = len(im_files)

    # in_files,_=writeInputImageFiles(im_files,in_file_pre,per_file);
    in_files = [in_file_pre + "_" + str(0) + ".txt"]
    print in_files
    out_files = []
    for idx, in_file_curr in enumerate(in_files):
        out_file_curr = out_file + "_" + str(idx)
        out_files.append(
            caffe_wrapper.saveFeaturesOfLayers(
                in_file_curr,
                path_to_classify,
                gpu_no,
                layers,
                ext=ext,
                out_file=out_file_curr,
                meanFile=caffe_mean,
                deployFile=caffe_deploy,
                modelFile=caffe_model,
            )
        )

    print in_files
    print out_files

    file_list_all = []
    for in_file_curr in in_files:
        with open(in_file_curr, "rb") as f:
            file_list = f.readlines()
            file_list_all.extend([file_curr.strip("\n") for file_curr in file_list])
    print len(file_list_all)

    imagenet_idx_mapped, imagenet_ids_mapped, imagenet_labels_mapped = imagenet.getMappingInfo(
        file_list_all, synset_words, val_gt_file
    )

    print "about to combine"
    t = time.time()
    val_combined = combineDeepFeaturesFromFiles(out_files, layers)
    print time.time() - t

    for layer_curr in layers:
        print "about to nn for ", layer_curr
        t = time.time()
        indices, distances = nearest_neighbor.doCosineDistanceNN(val_combined[layer_curr], numberOfN=None)
        print time.time() - t
        #     break;
        # return

        print indices.shape
        print distances.shape

        print "writing to db"
        mani = Imagenet_Manipulator(db_path_out)
        mani.openSession()
        for idx in range(len(file_list_all)):
            if idx % 100 == 0:
                print layer_curr, idx, len(file_list_all)
            idx_out_file = idx / per_file
            out_file_layers = out_file + "_" + str(idx_out_file) + ".npz"

            mani.insert(
                idx,
                file_list_all[idx],
                layer_curr,
                out_file_layers,
                trainFlag,
                imagenet_idx_mapped[idx],
                imagenet_ids_mapped[idx],
                caffe_model,
                class_label_imagenet=imagenet_labels_mapped[idx],
                neighbor_index=indices[idx],
                neighbor_distance=distances[idx],
            )

        mani.closeSession()