def __init__(self, model_name):
"""
Arguments:
model_name (str): Name of trained supervised model for first step.
"""
self._model_name = model_name
self._model, self._feat_list, self._scaler, self._model_params = load_model(
self._model_name)
def test_process():
output_dir_for_model = './data/model.pkl.gz'
vocab_file = 'ende_32k.subword'
vocab_dir = '/home/dimitris/Documents/tutorials/NLP_specialization_coursera/course4_attension_models/week1new/data/'
EOS_index = 1
model = load_model(output_dir_for_model)
result = sampling_decode("i love you", model, 0.0, vocab_file, vocab_dir,
EOS_index)
print(result)
def load_model():
# model = utils.load_model('matches_f85_1hop', feature_amount=85)[0]
model = utils.load_model('matches_f85_th81', feature_amount=85)[0]
return model
import numpy as np
from glob import glob
from keras.applications.resnet50 import preprocess_input
from ml_utils import load_model, path_to_tensor
# Took this strange approach with hardcoding path length from notebook
# Hope there are more elegant ways to do it in python
# But for now I better save some time)
dog_names = [item[23:-1] for item in sorted(glob('../dogImages/train/*/'))]
dog_detector = load_model('dog_detector')
bottleneck = load_model('bottleneck')
loaded_model = load_model('model')
def predict_dog_labels(img_path):
# returns prediction vector for image located at img_path
img = preprocess_input(path_to_tensor(img_path))
return np.argmax(dog_detector.predict(img))
def detect_dog(img_path):
prediction = predict_dog_labels(img_path)
return ((prediction <= 268) & (prediction >= 151))
def predict_breed(img_path):
# extract bottleneck features
bottleneck_feature = bottleneck.predict(path_to_tensor(img_path))
# obtain predicted vector
predicted_vector = loaded_model.predict(bottleneck_feature)
def mouse_detector(board, board_size, px_size, screen):
logistic_reg_model = load_model("data/LR.sav")
knn_model = load_model("data/KNN.sav")
lda_model = load_model("data/LDA.sav")
nnet_model = load_model("data/NN.sav")
svd_model = load_model("data/SVD.sav")
stroke = 3
running = True
is_drawing = False
prediction = ''
while running:
for event in pygame.event.get():
mouse_pos = pygame.mouse.get_pos()
draw_screen(screen, board, board_size, event.type,
interaction_handler(screen, mouse_pos, board_size))
draw_prediction(screen, board_size, prediction)
strokeDraw = pygame.font.Font('freesansbold.ttf',
20).render('Stroke = ' + str(stroke),
True, (0, 0, 0))
stroke_rect = strokeDraw.get_rect()
stroke_rect.center = (screen.get_size()[0] * 4 / 5,
screen.get_size()[1] * 19 / 20)
if event.type == pygame.MOUSEBUTTONDOWN:
if (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.RESET):
prediction = ''
board = init_board()
elif (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.MLR):
prediction = logistic_regression_prediction(
logistic_reg_model, board)
elif (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.KNN):
prediction = knn_prediction(knn_model, board)
elif (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.LDA):
prediction = lda_prediction(lda_model, board)
elif (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.SVD):
prediction = svd_prediction(svd_model, board)
elif (interaction_handler(screen, mouse_pos,
board_size) == Click_Element.NN):
prediction = nnet_prediction(nnet_model, board)
is_drawing = True
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_KP_MINUS and stroke > 1:
stroke -= 2
elif event.key == pygame.K_KP_PLUS and stroke < 5:
stroke += 2
elif event.type == pygame.MOUSEMOTION:
if is_drawing and mouse_pos[0] < board_size and mouse_pos[
1] < board_size:
index = board_position_handler(mouse_pos, px_size)
if index != None:
draw_stroke(board, index[0], index[1], stroke)
elif event.type == pygame.MOUSEBUTTONUP:
is_drawing = False
if event.type == pygame.QUIT:
running = False
screen.blit(strokeDraw, stroke_rect)
pygame.display.update()
def load_model():
model = utils.load_model(profile['model'], feature_amount=85)[0]
return model