Pytorch - перебирает список сетей для оценки времени пересылки - не может загрузить следующую модель

Question

Мой код не загружает следующую сеть для оценки, он, похоже, просто продолжает оценивать ту же модель.

Следующий код выполняется в каталоге со многими подкаталогами моделей / сетей для оценки.для времени пересылки для набора размеров изображения.

Записанное время оценки не изменяется при каждом запуске сценария, однако, поскольку было добавлено перемешивание, время зависит от первой загруженной модели.

Код работает правильно, когда вручную делает каждый каталог отдельно.при запуске на множестве подкаталогов он повторяет тест в той же сетевой модели.

'' '

# !/usr/bin/python


import os
import numpy as np
import torch
import time
import importlib
import sys
from random import shuffle

from PIL import Image
from argparse import ArgumentParser

from torch.autograd import Variable

import torch.backends.cudnn as cudnn
cudnn.benchmark = True

NUM_CLASSES = 20



def getEval(args):
    cwd = os.getcwd()
    modelpath = cwd + "\\" +args.loadDir + '\\' + args.loadModel + ".py"

    print ("Loading model: " + modelpath)

    MODULE_DIR = cwd + "\\" +args.loadDir + '\\' 

    print("cwd", cwd)
    sys.path.append(MODULE_DIR)
    print ("sys path", sys.path)

    model_file = importlib.import_module(args.loadModel)
    model = model_file.Net(NUM_CLASSES)

    if (not args.cpu):
        model = model.cuda()#.half()    #HALF seems to be doing slower for some reason
    #model = torch.nn.DataParallel(model).cuda()

    model.eval()


    images1 = torch.randn(args.batch_size, args.num_channels, 2048, 1024)
    images2 = torch.randn(args.batch_size, args.num_channels, 1024, 512)
    images3 = torch.randn(args.batch_size, args.num_channels, 512, 256)
    images4 = torch.randn(args.batch_size, args.num_channels, 256, 256)


    images = [images1, images2, images3, images4]

    time_train = [[],[],[],[]]

    for j in range(0,4):

        inputs = Variable(images[j].cuda())

        for i in range(0,10):

            start_time = time.time()

            with torch.no_grad():
                outputs = model(inputs)

            #preds = outputs.cpu()
            if (not args.cpu):
                torch.cuda.synchronize()    #wait for cuda to finish (cuda is asynchronous!)

            if i != 0:    #first run always takes some time for setup
                fwt = time.time() - start_time
                time_train[j].append(fwt)
                print ("Forward time per img (b=%d): %.4f (Mean: %.4f)" % (args.batch_size, fwt/args.batch_size, sum(time_train[j]) / len(time_train[j]) / args.batch_size))

            time.sleep(1)   #to avoid overheating the GPU too much

    header = "2048x1024,1024x512,512x256,256x128"
    csvData = ''
    for size in range(0,4):
        csvData += '{}{:.4f}'.format("" if size == 0 else ",", sum(time_train[size]) / len(time_train[size]) / args.batch_size)
    print(header)
    print(csvData)

    # trying to clean things up from memory
    sys.path.remove(MODULE_DIR)
    del model
    del MODULE_DIR
    del model_file
    torch.cuda.empty_cache()

    return(csvData)


def main(args):
    with open('eval-win-speed.csv','w') as file:
        header = "2048x1024,1024x512,512x256,256x128"
        file.write('{},{}'.format("model_dir" ,header))
        file.write('\n')

    eval_values = []

    dirs = os.listdir(args.loadDir)
    shuffle(dirs)

    for dir in dirs:
        print(dir)

        if os.path.isdir(dir):
            print('is dir')
            class model_dir: 
                loadDir = dir
                loadModel = args.loadModel
                num_channels = args.num_channels
                batch_size = args.batch_size
                cpu = args.cpu

            eval = '{},{}\n'.format(dir, getEval(model_dir))

            with open('eval-win-speed.csv','a') as file:
                file.write(eval)

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('--loadDir',default="..\\trained_models\\")
    parser.add_argument('--loadWeights', default="model_best.pth")
    parser.add_argument('--loadModel', default="network")
    parser.add_argument('--num-channels', type=int, default=3)
    parser.add_argument('--batch-size', type=int, default=1)
    parser.add_argument('--cpu', action='store_true')

    main(parser.parse_args())

' ''

, ожидающих записи значительно разного времени пересылки для разных модельных сетей.