def train_hold_out(model,
criterion,
optimizer,
args,
train_set,
val_set,
test_set,
single_view=False):
"""
Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of
data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to
evaluate the model.
All the data are sent to wandb or logged on a text file
Parameters
----------
model : RotaitonNet model
criterion : Pytorch criterion (CrossEntropy for RotationNet)
optimizer : Pytorch optimizer (e.g. SGD)
args : Input args from the parser
Returns
-------
Nothing
"""
# Generate loaders
test_loader = DataLoader(test_set,
batch_size=args.batch_size,
shuffle=single_view,
num_workers=args.workers,
pin_memory=True,
drop_last=True)
val_loader = DataLoader(val_set,
batch_size=args.batch_size,
shuffle=single_view,
num_workers=args.workers,
pin_memory=True,
drop_last=True)
train_loader = DataLoader(train_set,
batch_size=args.batch_size,
shuffle=single_view,
num_workers=args.workers,
pin_memory=True,
drop_last=True)
# Track model in wandb
#wandb.init(project="MVCNN", config=args, reinit=True)
# wandb.watch(model)
train(model, criterion, optimizer, train_loader, val_loader, args,
single_view)
load_model(model, args.fname_best)
val_statistics = validate(test_loader, model, criterion, args, single_view)
log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def predict(environ, start_response):
# Load input image data from the HTTP request
request = Request(environ)
if not request.files:
return Response('no file uploaded', 400)(environ, start_response)
image_file = next(request.files.values())
image, inverted = process_image(Image.open(image_file))
# The predictor must be lazily instantiated;
# the TensorFlow graph can apparently not be shared
# between processes.
global model
if not model:
model = load_model('model.h5')
prediction = predict_image(model, image, inverted)
# The following line allows Valohai to track endpoint predictions
# while the model is deployed. Here we remove the full predictions
# details as we are only interested in tracking the rest of the results.
print(
json.dumps({
'vh_metadata':
{k: v
for k, v in prediction.items() if k != 'predictions'}
}))
# Return a JSON response
response = Response(json.dumps(prediction),
content_type='application/json')
return response(environ, start_response)
def main(page_title,
page_icon,
layout='centered',
initial_sidebar_state='expanded'):
# Config the streamlit app
st.set_page_config(page_title=page_title,
page_icon=page_icon,
layout=layout,
initial_sidebar_state=initial_sidebar_state)
# Load styles/assets
load_remote_css(
"https://cdn.jsdelivr.net/gh/rastikerdar/vazir-font/dist/font-face.css"
)
load_local_css(BASE_DIR + '/assets/style.css')
load_local_css(BASE_DIR + '/assets/rtl.css')
# Sidebar
# st.sidebar.image(logo, width=120)
st.sidebar.markdown('<h1 class="text-center">WikiSummary</h1>',
unsafe_allow_html=True)
st.sidebar.markdown(MODEL_DESC, unsafe_allow_html=True)
# Load examples
ex_names, ex_map = load_examples(BASE_DIR + '/assets/example.json')
# Main
example = st.selectbox('Choose an example', ex_names)
if ex_map[example][1]:
link = st.markdown(
f'<a class="rtl" href="{ex_map[example][1]}">{example}</a>',
unsafe_allow_html=True)
height = min((len(ex_map[example][0].split()) + 1) * 2, 200)
sequence = st.text_area('Text',
ex_map[example][0],
key='sequence',
height=height)
if len(sequence) == 0:
st.write('Enter some text to see summarization.')
return
with st.spinner('Loading the components ...'):
config = load_config(MODEL_NAME_OR_PATH)
tokenizer = load_tokenizer(MODEL_NAME_OR_PATH)
model = load_model(MODEL_NAME_OR_PATH, config=config)
# model = load_model(MODEL_NAME_OR_PATH)
with st.spinner('Summarizing ...'):
summary = generate_output(model, tokenizer, cleaning(sequence))
summary = summary[0] if len(summary) > 0 else summary
st.markdown(DISABLED_TEXTAREA.format(
**{
'attributes': 'class="generated-headline rtl"',
'value': f'<span class="r-label">خلاصه سازی</span> {summary}'
}),
unsafe_allow_html=True)
def eval_dataset(dataset, model_path, cfg):
model = SqueezeDet(cfg)
model = load_model(model, model_path)
detector = Detector(model, cfg)
results = detector.detect_dataset(dataset)
dataset.save_results(results)
aps = dataset.evaluate()
return aps
def main():
# valohai.prepare enables us to update the valohai.yaml configuration file with
# the Valohai command-line client by running `valohai yaml step batch_inference.py`
valohai.prepare(
step='batch-inference',
image='tensorflow/tensorflow:2.6.0',
default_inputs={
'model': {
'default': None,
'optional': False,
},
'images': [
'https://valohaidemo.blob.core.windows.net/mnist/four-inverted.png',
'https://valohaidemo.blob.core.windows.net/mnist/five-inverted.png',
'https://valohaidemo.blob.core.windows.net/mnist/five-normal.jpg',
],
},
)
print('Loading model')
model_path = valohai.inputs('model').path()
model = load_model(model_path)
json_blob = {}
for image_path in valohai.inputs('images').paths():
filename = os.path.basename(image_path)
extension = os.path.splitext(image_path)[1].lower()
if extension not in ['.png', '.jpg', '.jpeg', '.bmp', '.gif', '.tiff']:
print(f'{filename} is not an image file')
continue
print(f'Running inference for {filename}')
try:
image, inverted = process_image(Image.open(image_path))
prediction = predict_image(model, image, inverted)
json_blob[filename] = prediction
print(filename, prediction)
except Exception as exc:
json_blob[filename] = {'error': exc}
print(f'Unable to process {filename}: {exc}', file=sys.stderr)
print('Saving predictions')
suffix = ''
try:
suffix = f'-{model_path.split("model-")[1].split(".h5")[0]}'
except IndexError:
print(f'Unable to get suffix from {model_path}')
json_path = os.path.join(
valohai.outputs().path(f'predictions{suffix}.json'))
with open(json_path, 'w') as json_file:
json.dump(json_blob, json_file, sort_keys=True)
def do_sentiment(task_title, task_config_filename, do_print_code=False):
st.title(task_title)
config_names, config_map = task_configuration('assets/%s.json' %
task_config_filename)
example = st.selectbox('Choose an example', config_names)
# st.markdown(config_map[example][2], unsafe_allow_html=True)
height = min((len(config_map[example][0].split()) + 1) * 2, 200)
if config_map[example][4] == 'rtl':
local_css('assets/rtl.css')
sequence = st.text_area('Text',
config_map[example][0],
key='sequence',
height=height)
labels = st.text_input('Labels (comma-separated)',
config_map[example][1],
max_chars=1000)
original_labels = config_map[example][1].split(', ')
labels = list(
set([
x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0
]))
if len(labels) == 0 or len(sequence) == 0:
st.write('Enter some text and at least one label to see predictions.')
return
if not is_identical(labels, original_labels, 'list'):
st.write('Your labels must be as same as the NLP task `%s`' %
task_title)
return
if st.button('Analyze'):
if do_print_code:
load_snippet('snippets/sentiment_analysis_code.txt', 'python')
s = st.info('Predicting ...')
model_config = load_config(config_map[example][3])
labels = model_config.id2label
tokenizer = load_tokenizer(config_map[example][3])
model = load_model(config_map[example][3],
'TFAlbertForSequenceClassification')
scores, prediction = sequence_predicting(model, tokenizer, sequence,
labels)
time.sleep(1)
s.empty()
plot_result(list(labels.values()), scores, prediction)
def transcribe_file():
if os.path.exists(os.path.join(FLAGS.model_dir, 'hparams.json')):
_hparams = model_utils.load_hparams(FLAGS.model_dir)
encoder_fn, vocab_size = encoding.load_encoder(FLAGS.model_dir,
hparams=_hparams)
model, loss_fn = model_utils.load_model(FLAGS.model_dir,
vocab_size=vocab_size,
hparams=_hparams)
optimizer = tf.keras.optimizers.Adam(_hparams[HP_LEARNING_RATE.name])
model.compile(loss=loss_fn,
optimizer=optimizer,
experimental_run_tf_function=False)
else:
print('need afford model_dir ')
return
transcription = model.predict(FLAGS.test_file)
print('Input file: {}'.format(FLAGS.input))
print('Transcription: {}'.format(transcription))
def main(args):
hparams = model_utils.load_hparams(args.model_dir)
model, _ = model_utils.load_model(args.model_dir, hparams, stateful=True)
model.summary()
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.experimental_new_converter = True
# converter.experimental_new_quantizer = True
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS
]
# converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()
tflite_dir = os.path.join(args.model_dir, 'tflite')
os.makedirs(tflite_dir, exist_ok=True)
with open(os.path.join(tflite_dir, 'model.tflite'), 'wb') as f:
f.write(tflite_quant_model)
def demo(cfg):
# prepare configurations
cfg.load_model = '../models/squeezedet_kitti_epoch280.pth'
cfg.gpus = [-1] # -1 to use CPU
cfg.debug = 2 # to visualize detection boxes
dataset = KITTI('val', cfg)
cfg = Config().update_dataset_info(cfg, dataset)
# preprocess image to match model's input resolution
preprocess_func = dataset.preprocess
del dataset
# prepare model & detector
model = SqueezeDet(cfg)
model = load_model(model, cfg.load_model)
detector = Detector(model.to(cfg.device), cfg)
# prepare images
sample_images_dir = '../data/samples/kitti/testing/image_2'
sample_image_paths = glob.glob(os.path.join(sample_images_dir, '*.png'))
# detection
for path in tqdm.tqdm(sample_image_paths):
image = skimage.io.imread(path).astype(np.float32)
image_meta = {'image_id': os.path.basename(path)[:-4],
'orig_size': np.array(image.shape, dtype=np.int32)}
image, image_meta, _ = preprocess_func(image, image_meta)
image = torch.from_numpy(image.transpose(2, 0, 1)).unsqueeze(0).to(cfg.device)
image_meta = {k: torch.from_numpy(v).unsqueeze(0).to(cfg.device) if isinstance(v, np.ndarray)
else [v] for k, v in image_meta.items()}
inp = {'image': image,
'image_meta': image_meta}
_ = detector.detect(inp)
def train(cfg):
Dataset = load_dataset(cfg.dataset)
train_dataset = Dataset('train', cfg)
val_dataset = Dataset('val', cfg)
cfg = Config().update_dataset_info(cfg, train_dataset)
Config().print(cfg)
logger = Logger(cfg)
model = SqueezeDetWithLoss(cfg)
if cfg.load_model != '':
if cfg.load_model.endswith('f364aa15.pth') or cfg.load_model.endswith(
'a815701f.pth'):
model = load_official_model(model, cfg.load_model)
else:
model = load_model(model, cfg.load_model)
optimizer = torch.optim.SGD(model.parameters(),
lr=cfg.lr,
momentum=cfg.momentum,
weight_decay=cfg.weight_decay)
lr_scheduler = StepLR(optimizer, 60, gamma=0.5)
trainer = Trainer(model, optimizer, lr_scheduler, cfg)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=cfg.batch_size,
num_workers=cfg.num_workers,
pin_memory=True,
shuffle=True,
drop_last=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=cfg.batch_size,
num_workers=cfg.num_workers,
pin_memory=True)
metrics = trainer.metrics if cfg.no_eval else trainer.metrics + ['mAP']
best = 1E9 if cfg.no_eval else 0
better_than = operator.lt if cfg.no_eval else operator.gt
for epoch in range(1, cfg.num_epochs + 1):
train_stats = trainer.train_epoch(epoch, train_loader)
logger.update(train_stats, phase='train', epoch=epoch)
save_path = os.path.join(cfg.save_dir, 'model_last.pth')
save_model(model, save_path, epoch)
if epoch % cfg.save_intervals == 0:
save_path = os.path.join(cfg.save_dir,
'model_{}.pth'.format(epoch))
save_model(model, save_path, epoch)
if cfg.val_intervals > 0 and epoch % cfg.val_intervals == 0:
val_stats = trainer.val_epoch(epoch, val_loader)
logger.update(val_stats, phase='val', epoch=epoch)
if not cfg.no_eval:
aps = eval_dataset(val_dataset, save_path, cfg)
logger.update(aps, phase='val', epoch=epoch)
value = val_stats['loss'] if cfg.no_eval else aps['mAP']
if better_than(value, best):
best = value
save_path = os.path.join(cfg.save_dir, 'model_best.pth')
save_model(model, save_path, epoch)
logger.plot(metrics)
logger.print_bests(metrics)
torch.cuda.empty_cache()
def do_text_generation(task_title, task_config_filename, do_print_code=False):
st.title(task_title)
config_names, config_map = task_configuration('assets/%s.json' %
task_config_filename)
example = st.selectbox('Choose an example', config_names)
# st.markdown(config_map[example][2], unsafe_allow_html=True)
height = min((len(config_map[example][0].split()) + 1) * 2, 200)
if config_map[example][4] == 'rtl':
local_css('assets/rtl.css')
sequence = st.text_area('Text',
config_map[example][0],
key='sequence',
height=height)
labels = st.text_input('Mask (placeholder)',
config_map[example][1],
max_chars=1000)
original_labels = config_map[example][1].split(', ')
labels = list(
set([
x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0
]))
if len(labels) == 0 or len(sequence) == 0:
st.write('Enter some text and at least one label to see predictions.')
return
if not is_identical(labels, original_labels, 'list'):
st.write('Your labels must be as same as the NLP task `%s`' %
task_title)
return
if st.button('Analyze'):
if do_print_code:
load_snippet('snippets/text_generation_code.txt', 'python')
s = st.info('Predicting ...')
tokenizer = load_tokenizer(config_map[example][3])
model = load_model(config_map[example][3],
'TFAlbertForMaskedLM',
from_pt=True)
masked_words, words = text_generation(model, tokenizer, sequence)
new_sequence = []
for index, word in enumerate(words):
if index in masked_words:
masks_sequence = []
for mi in masked_words[index]:
masks_sequence.append(
'<span class="masked" style="background-color: %s;">%s</span>'
% (mi['color'], mi['token_str']))
new_sequence.append(
'<span class="token"><span class="masks-start">[</span><span class="token-masks">%s</span><span class="masks-end">]</span></span>'
% (''.join(masks_sequence)))
else:
new_sequence.append('<span class="token">%s</span>' % word)
new_sequence = ' '.join(new_sequence)
time.sleep(1)
s.empty()
st.markdown(f'<p class="masked-box">{new_sequence}</p>',
unsafe_allow_html=True)
def do_ner(task_title, task_config_filename, do_print_code=False):
st.title(task_title)
config_names, config_map = task_configuration('assets/%s.json' %
task_config_filename)
example = st.selectbox('Choose an example', config_names)
# st.markdown(config_map[example][2], unsafe_allow_html=True)
height = min((len(config_map[example][0].split()) + 1) * 2, 200)
if config_map[example][4] == 'rtl':
local_css('assets/rtl.css')
sequence = st.text_area('Text',
config_map[example][0],
key='sequence',
height=height)
labels = st.text_input('Labels (comma-separated)',
config_map[example][1],
max_chars=1000)
original_labels = config_map[example][1].split(', ')
labels = list(
set([
x.strip() for x in labels.strip().split(',') if len(x.strip()) > 0
]))
if len(labels) == 0 or len(sequence) == 0:
st.write('Enter some text and at least one label to see predictions.')
return
if not is_identical(labels, original_labels, 'list'):
st.write('Your labels must be as same as the NLP task `%s`' %
task_title)
return
if st.button('Analyze'):
if do_print_code:
load_snippet('snippets/named_entity_recognition_code.txt',
'python')
s = st.info('Predicting ...')
model_config = load_config(config_map[example][3])
labels = model_config.id2label
mapper = config_map[example][5]
# labels = {k: labels_mapper[v] for k, v in model_config.id2label.items()}
tokenizer = load_tokenizer(config_map[example][3])
model = load_model(config_map[example][3],
'TFAlbertForTokenClassification')
predictions = token_predicting(model, tokenizer, sequence, labels)
ner_color = []
ner_tags = []
for tag, translate in mapper.items():
if tag != 'O':
if translate[0] not in ner_tags:
ner_color.append(
'<span style="background-color: %s;">%s</span>' %
(translate[1], translate[0]))
ner_tags.append(translate[0])
ner_color = ' '.join(ner_color)
ner_sequence = []
for token, label in predictions:
if token not in ['[CLS]', '[SEP]']:
label = mapper[label]
if label[0]:
ner_sequence.append(
'<span style="background-color: %s;" class="token token-ner">%s <span class="ner-label">%s</span></span>'
% (label[1], token, label[0]))
else:
ner_sequence.append('<span class="token">%s</span>' %
token)
time.sleep(1)
s.empty()
st.markdown(f'<p class="ner-color">{ner_color}</p>',
unsafe_allow_html=True)
ner_sequence = ' '.join(ner_sequence)
st.markdown(f'<p class="ner-box">{ner_sequence}</p>',
unsafe_allow_html=True)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
_ROOT_PATH = str(pathlib.PurePath(__file__).parent)
_DATA = [TMA1, TMA2, TMA3]
_JSON_DATA = [
df.head(10000).to_json(orient='table', index=False) for df in _DATA
]
_DEAD_KNN_MODEL, _INJURED_KNN_MODEL = analyse.KNN(TMA1)
# _DEAD_KNN_MODEL, _INJURED_KNN_MODEL = analyse.KNN(pd.concat([TMA1, TMA2], ignore_index=True))
_SVM_MODEL = analyse.SVM(pd.concat([TMA1, TMA2], ignore_index=True))
_RNN_MODEL = model.load_model('./static/data/model')
_KMEANS_MODEL = analyse.kmeans(TMA1)
@app.route('/', methods=['GET'])
def index():
return render_template('index.html',
dataSize=[len(d) for d in (TMA1, TMA2, TMA3)])
'''
@app.route('/buttons', methods=['GET'])
def buttons():
return render_template('buttons.html')
'''
'''
import pandas as pd
from feature_generation.feature_annotator import FeatureAnnotator
from constants.paths import PRETRAINED_BEST_MODEL_PATH
from constants.model import PAIR_FILTER_TYPE, FEATURE_FILTER_TYPE
from utils.model import load_model, load_word_vec, load_one_hot_encoder, load_label_encoder
# Feature generations
from feature_generation.dependency_pair import create_dependency_parser_feature_from_sentence
from preprocessing.model_feature import feature_selection, preprocess, filter_pair
# Post process
from postprocess.amr_graph import create_pediction_dict, create_amr_graph_from_prediction
annotator = FeatureAnnotator()
model = load_model(PRETRAINED_BEST_MODEL_PATH)
word_vec = load_word_vec()
one_hot_encoder = load_one_hot_encoder()
label_encoder = load_label_encoder()
def process_sentence(sentence, sentence_id=0):
dependency_parser_feature = create_dependency_parser_feature_from_sentence(
annotator, sentence)
X = pd.DataFrame(dependency_parser_feature)
filtered_X = filter_pair(X, PAIR_FILTER_TYPE)
return filtered_X
def predict_and_process(filtered_X):
selected_X = feature_selection(filtered_X, FEATURE_FILTER_TYPE)
X_preprocessed = preprocess(selected_X, word_vec, one_hot_encoder)
y_pred = model.predict(X_preprocessed)
def getStyleBased(subModel):
return load_model('STYLE-BASED', subModel);
from utils.utils import get_acc
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', type=str, default='chestx')
parser.add_argument('--model', type=str, default='inceptionv3')
parser.add_argument('--gpu', type=str, default='0')
args = parser.parse_args()
set_gpu(args.gpu)
X_train, X_test, y_train, y_test = load_data(
dataset=args.dataset, normalize=True)
model = load_model(
dataset=args.dataset,
nb_class=y_train.shape[1],
model_type=args.model,
mode='train'
)
def step_decay(epoch):
lr = 1e-3
if epoch > 45:
lr = 1e-5
elif epoch > 40:
lr = 1e-4
print('Learning rate: ', lr)
return lr
epoch = 50
default=416,
type=int,
help="Width of network's input image")
parser.add_argument("--inpHeight",
default=416,
type=int,
help="Height of network's input image")
parser.add_argument("--image",
default=None,
type=str,
help="path of image")
parser.add_argument("--video",
default=None,
type=str,
help="path of video")
args = parser.parse_args()
return args
if __name__ == '__main__':
# load model
args = getargs()
net, classes = model.load_model(args)
if args.image:
image = cv.imread(args.image)
utils.process_img(args, net, image, classes)
elif args.video:
utils.process_video(args, net, classes)
def main():
args = parser.parse_args()
torch.manual_seed(0)
np.random.seed(0)
# Set the cuda device
if torch.cuda.is_available():
device = torch.device("cuda:0")
torch.cuda.set_device(device)
else:
device = torch.device("cpu")
if args.net_version == 1:
from view_net import Model
else:
from view_net2 import Model
# Initialize an OpenGL perspective camera.
cameras = OpenGLPerspectiveCameras(device=device)
# To blend the 100 faces we set a few parameters which control the opacity and the sharpness of
# edges. Refer to blending.py for more details.
# blend_params = BlendParams(sigma=1e-4, gamma=1e-4)
# We will also create a phong renderer. This is simpler and only needs to render one face per pixel.
raster_settings = RasterizationSettings(
image_size=224,
blur_radius=0.0, # np.log(1. / 1e-4 - 1.) * blend_params.sigma,
faces_per_pixel=args.faces_per_pixel, # 100
)
# We can add a point light in front of the object.
# lights = PointLights(device=device)
# lights = DirectionalLights(device=device, direction=self.camera_position)
phong_renderer = MeshRenderer(
rasterizer=MeshRasterizer(cameras=cameras,
raster_settings=raster_settings),
shader=HardFlatShader(device=device,
cameras=cameras) # , lights=lights)
)
dataset = ClassificationData(args.data, "train", device)
test_idx, train_idx = dataset.train_test_split(dataset.paths,
range(len(dataset)), 20,
True)
val_idx, train_idx = dataset.train_test_split(
[dataset.paths[i] for i in train_idx], train_idx, 20, True)
test_set = torch.utils.data.Subset(dataset, test_idx)
val_set = torch.utils.data.Subset(dataset, val_idx)
train_set = torch.utils.data.Subset(dataset, train_idx)
train_loader = DataLoader(train_set,
batch_size=args.batch_size // args.nviews,
shuffle=False,
num_workers=0,
pin_memory=True,
drop_last=True,
collate_fn=my_collate)
val_loader = DataLoader(val_set,
batch_size=args.batch_size // args.nviews,
shuffle=False,
num_workers=1,
pin_memory=True,
drop_last=True,
collate_fn=my_collate)
test_loader = DataLoader(test_set,
batch_size=args.batch_size // args.nviews,
shuffle=False,
num_workers=1,
pin_memory=True,
drop_last=True,
collate_fn=my_collate)
model = Model(device, phong_renderer, dataset.nclasses, args)
args.num_classes = dataset.nclasses
# Multi GPUs
if torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
model = model.to(device=device)
optimizer = Adam(
[
{
'params': model.camera_position,
'lr': args.learning_rate_camera
},
# {'params': model.light_position, 'lr': args.learning_rate_camera},
{
'params': model.net_1.parameters()
},
{
'params': model.net_2.parameters()
}
],
lr=args.learning_rate,
weight_decay=args.weight_decay)
criterion = nn.CrossEntropyLoss().to(device=device)
wandb.init(project="views_net", config=args)
args.fname_best = 'views_net{}_model_best{}.pth.tar'.format(
args.nviews,
datetime.now().strftime("%d_%b_%Y_%H_%M_%S"))
args.device = device
args.obj_path = train_set.dataset.paths[0][0]
train(model, criterion, optimizer, train_loader, val_loader, args)
load_model(model, args.fname_best)
val_statistics = validate(test_loader, model, criterion, device)
log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train_hold_out_aligned(model, criterion, optimizer, args):
"""
Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of
data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to
evaluate the model.
All the data are sent to wandb or logged on a text file
Parameters
----------
model : RotaitonNet model
criterion : Pytorch criterion (CrossEntropy for RotationNet)
optimizer : Pytorch optimizer (e.g. SGD)
args : Input args from the parser
Returns
-------
Nothing
"""
# create one element tuple to be consistent with ImageFolder dataset of Pytorch
full_set_train = (AlignedDataset(args.data_aligned, 'train', []),)
# validation data is on normal dataset
full_set_val = generate_dataset(args.data, 'train')
# full_set_val = (AlignedDataset(args.data_aligned, 'train', []),)
# Get test train split. The test set here is intended as validation set but because we need also a validation set
# for the early stopping we call it test
test_idx, train_idx = train_test_split(full_set_train[0].samples, range(len(full_set_train[0].samples)),
args.nview,
args.val_split_size, True)
# Get val train split
val_idx, train_idx = train_test_split([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview,
args.val_split_size, True)
_, classes = zip(*[full_set_train[0].samples[i] for i in train_idx])
# Get subsets
test_set = torch.utils.data.Subset(full_set_val[0], test_idx)
val_set = torch.utils.data.Subset(full_set_val[0], val_idx)
train_set = torch.utils.data.Subset(full_set_train[0], train_idx)
# Generate loaders
test_loader = generate_loader(test_set, args.batch_size, args.workers)
val_loader = generate_loader(val_set, args.batch_size, args.workers)
train_loader = generate_loader(train_set, args.batch_size, args.workers)
# load already trained model from single image classification
# load_model(model, "for_rotation_net.pth.tar")
# Track model in wandb
wandb.init(project="RotationNet", config=args)
# wandb.watch(model)
train(model, criterion, optimizer, train_loader, val_loader, args)
# Load best model before validating
load_model(model, args.fname_best)
# permute indices
# indices = test_loader.dataset.indices
# inds = random_permute_indices(np.array(indices), args.nview, True)
# test_loader.dataset.indices = np.asarray(inds)
# del indices
# del inds
val_statistics = validate(test_loader, model, criterion, args)
log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train_k_fold(model, criterion, optimizer, args):
"""
Perform a k-fold cross validation on the given model. Use args.fold to set the number of total folds and
args.ntest_fold to set the number of folds dedicated for the validation. Keep in mind that each training step uses
also an extra validation set for early stopping (the size of this subset is set via args.val_split_size).
All the data are sent to wandb or logged on a text file
Parameters
----------
model : RotaitonNet model
criterion : Pytorch criterion (CrossEntropy for RotationNet)
optimizer : Pytorch optimizer (e.g. SGD)
args : Input args from the parser
Returns
-------
Nothing
"""
# Save clean model to reload at each fold
save_model(args.arch, model, optimizer, args.fname)
# Get full train dataset
full_set = generate_dataset(args.data, 'train')
# Get folds
folds = k_fold(full_set[0].samples, args.nview, True, args.fold)
# List of top1 and top5 accuracies to get the average and std of the model performance
top1 = []
top5 = []
# K-fold cross validation
for i in range(args.fold):
test_idx = []
# Use ntest_folds folds for the test set
for j in range(args.ntest_folds):
test_idx.extend(folds[i])
folds = np.delete(folds, i, 0)
# Use rest of the data for the train set
train_idx = np.hstack(folds)
val_idx, train_idx = train_test_split([full_set[0].samples[i] for i in train_idx], train_idx, args.nview,
args.val_split_size, True)
# Get subsets
test_set = torch.utils.data.Subset(full_set[0], test_idx)
val_set = torch.utils.data.Subset(full_set[0], val_idx)
train_set = torch.utils.data.Subset(full_set[0], train_idx)
# Generate loaders
test_loader = generate_loader(test_set, args.batch_size, args.workers)
val_loader = generate_loader(val_set, args.batch_size, args.workers)
train_loader = generate_loader(train_set, args.batch_size, args.workers)
logger.debug("Start train on fold {}/{}".format(i, args.fold))
# Track model in wandb
wandb.init(project="RotationNet", name="Fold " + str(i), config=args, reinit=True)
# The model can be analyzed only once
# if i == 0:
# wandb.watch(model)
train(model, criterion, optimizer, train_loader, val_loader, args)
# Load best model before validating
load_model(model, args.fname_best)
val_statistics = validate(test_loader, model, criterion, args)
log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
# Load fresh model for next train
load_model(model, args.fname)
logger.info('Val prec@1 {top1:.3f} +- {std1:.3f} \t'
'Val prec@5 {top5:.3f} +- {std5:.3f} \t'.format(top1=np.mean(top1), std1=np.std(top1),
top5=np.mean(top5), std5=np.std(top5)))
# sample_rate_list=[32000]
n = 0
for sample_rate in sample_rate_list:
# resample audio and put them into a single h5 file.
util.make_h5('./audio_test', sr=sample_rate)
#load test data from h5 file.
X_test = util.load_test_data(sample_rate)
# load trained 5 models' path (same models but 5-fold cross validated)
model_list = glob.glob('saved_models/%s/**/*.h5' % sample_rate)
for model_name in model_list:
#load each model
m = model.load_model(model_name)
# model predict
pred = model.predict(m, X_test, n_class=41)
# ensemble with geometric mean
if n == 0:
total_pred = pred
else:
total_pred *= pred
n += 1
result = total_pred**(1 / float(n))
#######################################
# save submission by the format for MAP@3 evaluation.
def train_hold_out(model, criterion, optimizer, args):
"""
Perform a train with validation train split on the given model. Use args.val_split_size to set the percentage of
data for the validation set. Keep in mind the two validation sets are genereted. One for early stopping and one to
evaluate the model.
All the data are sent to wandb or logged on a text file
Parameters
----------
model : RotaitonNet model
criterion : Pytorch criterion (CrossEntropy for RotationNet)
optimizer : Pytorch optimizer (e.g. SGD)
args : Input args from the parser
Returns
-------
Nothing
"""
trans = []
if args.flip:
# flip is with 0.5 probability
trans.append(transforms.RandomHorizontalFlip())
trans.append(transforms.RandomVerticalFlip())
if args.rotation:
trans.append(transforms.RandomRotation((0, 90), expand=args.rotation_expand))
# if expand is true then resize the image to the right size
if args.rotation_expand:
trans.append(transforms.Resize(224))
# Get full train dataset
# Create two different sets but one with and one without transformations (random rotation and flip)
if args.depth:
# create one element tuple to be consistent with ImageFolder dataset of Pytorch
full_set_train = (DepthDataset(args.data, 'train', trans),)
full_set_val = (DepthDataset(args.data, 'train'),)
else:
full_set_train = generate_dataset(args.data, 'train', trans)
full_set_val = generate_dataset(args.data, 'train',[])
# Get test train split. The test set here is intended as validation set but because we need also a validation set
# for the early stopping we call it test
test_idx, train_idx = train_test_split(full_set_train[0].samples, range(len(full_set_train[0].samples)),
args.nview,
args.val_split_size, True)
# Get val train split
val_idx, train_idx = train_test_split([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview,
args.val_split_size, True)
if args.nelements != 0:
train_idx = under_sampler_to([full_set_train[0].samples[i] for i in train_idx], train_idx, args.nview,
args.nelements)
_, classes = zip(*[full_set_train[0].samples[i] for i in train_idx])
if args.sampling == "oversampling":
train_idx = random_over_sampler(classes, train_idx, args.nview)
elif args.sampling == "undersampling":
train_idx = random_under_sampler(classes, train_idx, args.nview)
# Get subsets
test_set = torch.utils.data.Subset(full_set_val[0], test_idx)
val_set = torch.utils.data.Subset(full_set_val[0], val_idx)
train_set = torch.utils.data.Subset(full_set_train[0], train_idx)
# Generate loaders
test_loader = generate_loader(test_set, args.batch_size, args.workers)
val_loader = generate_loader(val_set, args.batch_size, args.workers)
train_loader = generate_loader(train_set, args.batch_size, args.workers)
# load already trained model from single image classification
# load_model(model, "for_rotation_net.pth.tar")
# Track model in wandb
wandb.init(project="RotationNet", config=args)
# wandb.watch(model)
train(model, criterion, optimizer, train_loader, val_loader, args)
# Load best model before validating
load_model(model, args.fname_best)
# permute indices
# indices = test_loader.dataset.indices
# inds = random_permute_indices(np.array(indices), args.nview, True)
# test_loader.dataset.indices = np.asarray(inds)
# del indices
# del inds
val_statistics = validate(test_loader, model, criterion, args)
log_summary(val_statistics, "val", test_loader.dataset.dataset.classes)
def train():
hparams = {
HP_TOKEN_TYPE: HP_TOKEN_TYPE.domain.values[0],
HP_VOCAB_SIZE: HP_VOCAB_SIZE.domain.values[0],
# Preprocessing
HP_MEL_BINS: HP_MEL_BINS.domain.values[0],
HP_FRAME_LENGTH: HP_FRAME_LENGTH.domain.values[0],
HP_FRAME_STEP: HP_FRAME_STEP.domain.values[0],
HP_HERTZ_LOW: HP_HERTZ_LOW.domain.values[0],
HP_HERTZ_HIGH: HP_HERTZ_HIGH.domain.values[0],
# Model
HP_EMBEDDING_SIZE: HP_EMBEDDING_SIZE.domain.values[0],
HP_ENCODER_LAYERS: HP_ENCODER_LAYERS.domain.values[0],
HP_ENCODER_SIZE: HP_ENCODER_SIZE.domain.values[0],
HP_TIME_REDUCT_INDEX: HP_TIME_REDUCT_INDEX.domain.values[0],
HP_TIME_REDUCT_FACTOR: HP_TIME_REDUCT_FACTOR.domain.values[0],
HP_PRED_NET_LAYERS: HP_PRED_NET_LAYERS.domain.values[0],
HP_JOINT_NET_SIZE: HP_JOINT_NET_SIZE.domain.values[0],
HP_SOFTMAX_SIZE: HP_SOFTMAX_SIZE.domain.values[0],
HP_LEARNING_RATE: HP_LEARNING_RATE.domain.values[0]
}
if os.path.exists(os.path.join(FLAGS.model_dir, 'hparams.json')):
_hparams = model_utils.load_hparams(FLAGS.model_dir)
encoder_fn, vocab_size = encoding.load_encoder(FLAGS.model_dir,
hparams=_hparams)
model, loss_fn = model_utils.load_model(FLAGS.model_dir,
vocab_size=vocab_size,
hparams=_hparams)
else:
_hparams = {k.name: v for k, v in hparams.items()}
texts_gen = common_voice.texts_generator(FLAGS.data_dir)
encoder_fn, vocab_size = encoding.build_encoder(
texts_gen, model_dir=FLAGS.model_dir, hparams=_hparams)
model, loss_fn = build_keras_model(vocab_size, _hparams)
logging.info('Using {} encoder with vocab size: {}'.format(
_hparams[HP_TOKEN_TYPE.name], vocab_size))
dataset_fn = get_dataset_fn(FLAGS.data_dir,
encoder_fn=encoder_fn,
batch_size=FLAGS.batch_size,
hparams=hparams)
train_dataset, train_steps = dataset_fn('train')
dev_dataset, dev_steps = dataset_fn('dev')
optimizer = tf.keras.optimizers.Adam(_hparams[HP_LEARNING_RATE.name])
model.compile(loss=loss_fn,
optimizer=optimizer,
experimental_run_tf_function=False)
os.makedirs(FLAGS.model_dir, exist_ok=True)
checkpoint_fp = os.path.join(FLAGS.model_dir,
'model.{epoch:03d}-{val_loss:.4f}.hdf5')
model_utils.save_hparams(_hparams, FLAGS.model_dir)
model.fit(train_dataset,
epochs=FLAGS.n_epochs,
steps_per_epoch=train_steps,
validation_data=dev_dataset,
validation_steps=dev_steps,
callbacks=[
tf.keras.callbacks.TensorBoard(FLAGS.tb_log_dir),
tf.keras.callbacks.ModelCheckpoint(checkpoint_fp,
save_weights_only=True)
])
def main():
args = parser.parse_args()
# REPRODUCIBILITY
torch.manual_seed(0)
np.random.seed(0)
args.vcand = np.load('view_candidates/vcand_case2.npy')
args.nview = 20
if torch.cuda.is_available():
args.device = torch.device('cuda')
else:
args.device = torch.device('cpu')
# Create RotationNet model based on the given architecture.
# The output size is (num_classes + wrong_view class) * the number of views
model = RotationNet("alexnet", True, (args.num_classes + 1) * args.nview)
# Multi GPUs
if torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
# Send model to GPU or keep it to the CPU
model = model.to(device=args.device)
# switch to evaluate mode
model.eval()
model = torch.nn.DataParallel(model)
load_model(model, args.model_path, 'cpu')
in_dir = "../../others/separate_meshes/results/non_dirty1"
out_dir = "../../others/separate_meshes/results/recognition"
if os.path.exists(out_dir):
shutil.rmtree(out_dir)
os.mkdir(out_dir)
for filename in os.listdir(in_dir):
if filename.endswith(".obj"):
args.data = os.path.join(in_dir, filename)
# delete previous folder
if os.path.exists('inference_img'):
shutil.rmtree('inference_img')
os.mkdir("inference_img")
os.mkdir("inference_img/train/")
os.mkdir("inference_img/train/class")
args.folder = os.path.abspath("inference_img/train/class")
render_images(args)
test_set = (generate_dataset("inference_img", 'train', trans=[]), )
test_set = torch.utils.data.Subset(test_set[0],
range(len(test_set[0].samples)))
test_loader = generate_loader(test_set, args.nview, workers=0)
with torch.no_grad():
# input_val, target_val = next(iter(test_loader))
for batch_idx, (input_val,
target_val) in enumerate(test_loader):
prediction, score, _, _ = execute_inference(
model, input_val, target_val, args)
if score[0] < args.threshold:
cat = "outlier"
else:
cat = classes[prediction[0]]
input_val = None
del input_val
target_val = None
del target_val
test_set = None
del test_set
test_loader = None
del test_loader
print(cat)
if not os.path.exists(os.path.join(out_dir, cat)):
os.mkdir(os.path.join(out_dir, cat))
os.rename(os.path.join(in_dir, filename),
os.path.join(out_dir, cat, filename))
# sys.exit()
else:
continue
