Implementing Finetuning and Triplet Networks in n-shot Learning

Question

I am currently working on an n-shot learning project, and I have a few questions regarding the implementation of finetuning and triplet networks within the context of n-shot learning.

Can finetuning and triplet networks be applied in n-shot learning scenarios? If you could give more insights it would be helpful.

Here is the code for Finetuning:

if 'tsn' == opts.testType:
        print('start run n_shot test...')
        trsnList = [100,200,400,800]
        tesnList = [2000] * len(trsnList)
        snList = zip(trsnList, tesnList)
        # tsnList = [5]
        resultFile = os.path.join(ResDir, 'tune_model_{}_to_{}.txt'.format(source, target))
        f = open(resultFile, 'a+')
        print('\n\n##################### test time is: {} ####################'.format(time.ctime()), flush=True,
              file=f)
        X, y, _, _, NUM_CLASS = load_slice_IQ.loadData(dataOpts, split=False)
        yy = to_categorical(y)
        old_m = load_model(model.trainModelPath)
        _, ori_acc = old_m.evaluate(X, yy, batch_size=100, verbose=1)
        rtnLine += 'ori_acc: {:f}'.format(ori_acc)
        for sn in snList:
            # opts.nShot = trsn
            acc_list, acc_top5_list = [], []
            for i in range(test_times):
                X_train, y_train, X_test, y_test, NUM_CLASS = prepareData(X, y, sn[0], sn[1])

                print('tune data shape: ', X_train.shape)
                print('tune the model...')
                acc, acctop5 = model.tune(X_train, y_train, X_test, y_test, NUM_CLASS)
                acc_list.append(acc)
                acc_top5_list.append(acctop5)
            rtnLine = rtnLine + 'model: {}, stride={}, trsn={}, test={}, tune model with data {}, acc is: {:f}, and std is: {:f}\n'.format(
                    opts.modelType, dataOpts.stride, sn[0], sn[1], model.tuneData, mean(acc_list), stdev(acc_list))
        print(rtnLine, file=f, flush=True)
        f.close()

And Here is the code for triplet network:

def Wang_Disjoint_Experment(opts, modelPath, n_shot, max_n = 20):
    '''
    This function aims to experiment the performance of TF attack
    when the model is trained on the dataset with different distributions.
    The model is trained on AWF777 and tested on Wang100 and the set of
    websites in the training set and the testing set are mutually exclusive.
    '''
    features_model = load_model(modelPath, compile=False)
    # N-MEV is the use of mean of embedded vectors as mentioned in the paper

    type_exp = 'N-MEV'

    # KNeighborsClassifier(n_neighbors=n_shot, weights='distance', p=2, metric='cosine', algorithm='brute')
    params = {'k': n_shot,
              'weights': 'distance',
              'p': 2,
              'metric': 'cosine'
              }

    print("N_shot: ", n_shot)
    acc_list_Top1, acc_list_Top5 = [], []
    exp_times = 2
    total_time = 0

    for i in range(exp_times):
        # signature_dict, test_dict, sites = utility.getRFdataDict(opts.input, n_shot, data_dim, train_pool_size=20, test_size=70)
        signature_dict, test_dict, sites = getRFdataDict(opts.testData, opts, n_shot, n_instance=(2000 + max_n), max_n=max_n)
        if i == 0:
            size_of_problem = len(list(test_dict.keys()))
            print("Size of Problem: ", size_of_problem)
        signature_vector_dict, test_vector_dict = create_test_set_Wang_disjoint(signature_dict,
                                                                                test_dict,
                                                                                sites,
                                                                                features_model=features_model,
                                                                                type_exp=type_exp)
        # Measure the performance (accuracy)
        start = time.time()
        acc_knn_top1, acc_knn_top5 = kNN_accuracy(signature_vector_dict, test_vector_dict, params)
        end = time.time()
        total_time += (end-start)
        acc_list_Top1.append(float("{0:.15f}".format(round(acc_knn_top1, 5))))
        acc_list_Top5.append(float("{0:.15f}".format(round(acc_knn_top5, 5))))

    print(str(acc_list_Top1).strip('[]'))
    print(str(acc_list_Top5).strip('[]'))
    rtnLine = 'n_shot: {}\tacc for top 1: {} and std is: {}\n'.format(n_shot, mean(acc_list_Top1), stdev(acc_list_Top1))
    rtnLine = rtnLine + '\nacc for top 5: {} and std is: {}\n'.format(mean(acc_list_Top5), stdev(acc_list_Top5))
    rtnLine = rtnLine + '\nKNN training time : {}\n'.format(total_time/exp_times)
    print(rtnLine)
    return rtnLine