def train(dataset_path: str, save_path: str, weights: Optional[str]) -> None:
"""
Training hat/beards classifier.
:param dataset_path: path to full dataset.
:param save_path: path to save weights and training logs.
:param weights: path to saved model weights.
"""
log_dir = os.path.join(save_path, LOGS_DIR)
os.makedirs(log_dir, exist_ok=True)
train_data_gen = DataGenerator(dataset_path, is_train=True)
test_data_gen = DataGenerator(dataset_path, is_train=False)
model = get_model(weights)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(LEARNING_RATE),
metrics=[
Recall(NUM_CLASSES),
Precision(NUM_CLASSES),
F1Score(NUM_CLASSES), 'accuracy'
])
model.summary()
with LogCallback(save_path, log_dir) as log_callback:
callbacks = [
keras.callbacks.TensorBoard(log_dir=log_dir), log_callback
]
model.fit_generator(generator=train_data_gen,
validation_data=test_data_gen,
validation_freq=1,
validation_steps=len(test_data_gen),
epochs=EPOCHS,
callbacks=callbacks,
workers=min(24, cpu_count()))
def result():
body_list = ["筋肉型","標準型","痩せ型","肥満型"]
# submitした画像が存在したら、画像データをモデル用に整形
try :
if request.files['image']:
img_file = request.files['image']
temp_img = Image.open(request.files['image'])
temp_img = temp_img.convert("RGB") #色空間をRGBに
#今回は、モデルの精度を上げるために(64,64)で画像を学習させています。
temp_img = temp_img.resize((64,64))
temp_img = np.asarray(temp_img)
im_rows = 64
im_cols = 64
im_color = 3
in_shape = (im_rows,im_cols,im_color)
nb_classes = 4
img_array = temp_img.reshape(-1,im_rows,im_cols,im_color)
img_array = img_array / 255
model = cnn_model.get_model(in_shape,nb_classes)
#学習済みモデルを呼び出す
model.load_weights("photos-newmodel-light.hdf5")
predict = model.predict([img_array])[0]
index = predict.argmax()
body_shape = body_list[index]
body_score = 90*predict[0]+70*predict[1]+40*predict[2]+40*predict[3]
body_score = int(body_score)
return render_template('./result.html', title='結果', body_score=body_score,body_shape=body_shape,img_file=img_file)
except:
return render_template('./flask_api_index.html')
def deploy_model():
"""
Test model in real time
we will be getting screenshots and sending joystick input straight to the game
and see how it goes
:return:
"""
# getting the saved model
model = cnn_model.get_model()
model.summary()
j = pyvjoy.VJoyDevice(1) # this should be set according your device num
#running the infinite loop
while(True):
screenshot = np.array(ImageGrab.grab(bbox=(0, 40, 1024, 768)))
screenshot = data_preprocessing.transform_image(screenshot)
prediction = model.predict(np.array([screenshot]))
j.data.wAxisX = int(prediction[0][0] * constants.MAX_VJOY)
j.data.wAxisY = int(prediction[0][1] * constants.MAX_VJOY)
j.update()
print(prediction)
def train_model(self):
model = cnn_model.get_model()
model.compile(optimizer=Adam(lr=1e-4), loss='mse')
model.summary()
images = np.array(data_handler.x_data)
angles = data_handler.y_data
print("Images size", images.shape)
start_time = time.time()
history = model.fit(x=images,
y=angles,
batch_size=100,
epochs=self.epochs,
validation_split=self.val_split,
shuffle=True)
model.save(self.model_save_path + "/" + self.model_name)
training_time = time.time() - start_time
print("Total training time : " + str(training_time))
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, color='red', label='Training loss')
plt.plot(epochs, val_loss, color='green', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
def convert(weights: Optional[str]) -> None:
"""
Model conversion. The selected model will be saved in keras format (*.h5), tf 1.x frozen graph (*.pb)
and onnx (*.onnx). Model will be saved in folder "WEIGHTS_PATH/_(current date)/".
:param weights: path to saved keras model weights.
"""
keras.backend.set_learning_phase(0)
save_path = os.path.join(WEIGHTS_PATH, get_date()[2:])
os.makedirs(save_path, exist_ok=True)
if weights is None:
logger.warning(
'\nNo weights provided. Converting random initialized model.\n')
weights_name = 'random'
else:
weights_name = os.path.basename(weights)
shutil.copyfile(weights, os.path.join(save_path, weights_name))
model = get_model(weights)
if weights is None:
model.save(os.path.join(save_path, weights_name))
frozen_model_path = freeze_keras_model(model, save_path,
os.path.splitext(weights_name)[0],
list(OUTPUT_NAMES))
convert_frozen_graph_to_onnx(frozen_model_path, [INPUT_NAME],
OUTPUT_NAMES,
save_path,
opset=None)
def train():
# Training, validation, and testing sets
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
checkpoint = cnn_utils.get_model_saves_path()
x, y_, keep_prob, y_conv, variables = cnn_model.get_model()
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver(var_list=variables)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
# saver.restore(sess, checkpoint)
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
saver.save(sess, checkpoint)
train_accuracy = accuracy.eval(feed_dict={
x: batch[0],
y_: batch[1],
keep_prob: 1.0
})
print 'step %d, training accuracy %g' % (i, train_accuracy)
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print 'test accuracy %g' % accuracy.eval(feed_dict={
x: mnist.test.images,
y_: mnist.test.labels,
keep_prob: 1.0
})
sess.close()
def evaluate(dataset_path: str, weights: Optional[str]) -> None:
"""
Evaluate keras model on loss and training metrics. Function will print evaluating results on validation data.
:param dataset_path: path to full dataset.
:param weights: path to saved keras model weights.
"""
train_data_gen = DataGenerator(dataset_path, is_train=True)
test_data_gen = DataGenerator(dataset_path, is_train=False)
model = get_model(weights)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(LEARNING_RATE),
metrics=[
Recall(NUM_CLASSES),
Precision(NUM_CLASSES),
F1Score(NUM_CLASSES)
])
message = 'Testing model "{}".\n\n'.format(weights)
# Evaluate on training data.
message += 'Train data:\n'
results = model.evaluate_generator(train_data_gen,
workers=min(24, cpu_count()),
verbose=1)
for name, res in zip(model.metrics_names, results):
message += '{} = {:.04f}; '.format(name, res)
message = message[:-2] + '\n\nTest data:\n'
# Evaluate on testing data.
results = model.evaluate_generator(test_data_gen,
workers=min(24, cpu_count()),
verbose=1)
for name, res in zip(model.metrics_names, results):
message += '{} = {:.04f}; '.format(name, res)
message = message[:-2] + '\n'
logger.info('\n' + message)
import matplotlib.pyplot as plt
from calorie import calories
from cnn_model import get_model
import os
import cv2
import numpy as np
IMG_SIZE = 400
LR = 1e-3
no_of_fruits = 7
MODEL_NAME = 'Fruits_dectector-{}-{}.model'.format(LR, '5conv-basic')
model_save_at = os.path.join("model", MODEL_NAME)
model = get_model(IMG_SIZE, no_of_fruits, LR)
model.load(model_save_at)
labels = list(np.load('labels.npy'))
test_data = 'test5.jpg'
img = cv2.imread(test_data)
img1 = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
model_out = model.predict([img1])
result = np.argmax(model_out)
name = labels[result]
cal = round(calories(result+1, img), 2)
plt.imshow(img)
plt.title('{}({} cal)'.format(name, cal))
plt.axis('off')
from PIL import Image
import matplotlib.pyplot as plt
target_image = "test-sushi.jpg"
im_rows = 32 # 画像の縦ピクセルサイズ
im_cols = 32 # 画像の横ピクセルサイズ
im_color = 3 # 画像の色空間
in_shape = (im_rows, im_cols, im_color)
nb_classes = 3
LABELS = ["寿司", "サラダ", "麻婆豆腐"]
CALORIES = [588, 118, 648]
# 保存したCNNモデルを読み込む
model = cnn_model.get_model(in_shape, nb_classes)
model.load_weights('./image/photos-model.hdf5')
def check_photo(path):
# 画像を読み込む
img = Image.open(path)
img = img.convert("RGB") # 色空間をRGBに
img = img.resize((im_cols, im_rows)) # サイズ変更
plt.imshow(img)
plt.show()
# データに変換
x = np.asarray(img)
x = x.reshape(-1, im_rows, im_cols, im_color)
x = x / 255
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
SAVE_AUDIO = False
SAVE_IMAGE = True
audio_saved_count = 0
image_saved_count = 0
MODEL_TPYE = 'SVM'
cnn_weight_save_path = 'models/model2_checkpoint'
svm_model_path = 'models/svm_model'
test_data = 'test_data/'
if MODEL_TPYE == 'CNN':
my_model = get_model(n_class=10)
my_model.load_weights(cnn_weight_save_path)
if MODEL_TPYE == 'SVM':
my_model = joblib.load(svm_model_path)
block_buffer = []
recording = True
detected = False
def callback(in_data, frame_count, time_info, flag):
global block_buffer, detected, recording
signal_block = np.frombuffer(in_data, dtype=np.int16)
audio_valid = np.max(signal_block) - np.min(
def model_set(self, model_path):
print("model set")
self.model = cnn_model.get_model(self.in_shape, len(LABELS))
self.model.load_weights(model_path)
def output():
if request.method == "POST":
inputimg = request.files['user_img']
import cnn_model
import keras
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from keras.models import load_model
import cv2
from keras import backend as K
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import load_model
im_rows = 64 # 이미지의 높이
im_cols = 64 # 이미지의 너비
im_color = 3 # 이미지의 색공간
in_shape = (im_rows, im_cols, im_color)
nb_classes = 7
LABELS = ["꼬부기", "치코리타", "잠만보", "뽀뽀라", "케이시", "푸린", "리아코"]
# 저장한 CNN 모델 읽어 들이기
model = cnn_model.get_model(in_shape, nb_classes)
# CNN 모델 읽기
model = load_model('photos-cnn-model.h5')
# 학습된 데이타 불러오기
model.load_weights('photos-cnn-weight.hdf5')
# MLP로 학습한 이미지 데이터에 형태 맞추기
# im = im.reshape(in_shape).astype('float32') / 255
# 이미지 읽어 들이기
img = Image.open(
inputimg) #<class 'PIL.JpegImagePlugin.JpegImageFile'>
#img = img.convert("RGB") # 색공간 변환하기
#img = img.resize((im_cols, im_rows)) # 크기 변경하기
# 데이터 변환하기
n_img = np.asarray(img)
n_img = cv2.cvtColor(n_img, cv2.COLOR_BGR2RGB)
cv2.imwrite("test_before.jpg", n_img)
cascade_file = "haarcascade_frontalface_alt.xml" # 정면 얼굴 검출
cascade = cv2.CascadeClassifier(cascade_file)
img_gray = cv2.cvtColor(n_img, cv2.COLOR_BGR2GRAY)
face_list = cascade.detectMultiScale(
img_gray, minSize=(30, 30)) # miniSize - 얼굴 인식 영역의 최소 크기 지정
if len(face_list) == 1:
for (x, y, w, h) in face_list:
#print("얼굴의 좌표 =", x, y, w, h)
dst = n_img.copy() ####이미지복사해서
dst = n_img[y:y + h, x:x + w] ###자르기
cv2.imwrite("test_after.jpg", dst)
dst = Image.fromarray(dst, 'RGB')
dst = dst.resize((im_cols, im_rows))
dst = np.asarray(dst)
cv2.imwrite("test_resize.jpg", dst)
dst = dst.reshape(-1, im_rows, im_cols, im_color)
dst = dst / 255
# 예측하기
pre = model.predict([dst])[0]
K.clear_session()
idx = pre.argmax()
result_pm = LABELS[idx]
elif len(face_list) != 1:
result_pm = "메타몽"
return render_template("output.html", result_pm=result_pm)
def fool():
# Training, validation, and testing sets
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
x, y_, keep_prob, y_conv, variables = cnn_model.get_model()
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
grad = tf.gradients(cross_entropy, x)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Create session
sess = tf.InteractiveSession()
saver = tf.train.Saver(variables)
# sess.run(tf.global_variables_initializer())
saver.restore(sess, cnn_utils.get_model_saves_path())
two_image = None
two_onehot = None
index = 0
num_test_examples = mnist.test.num_examples
while index < num_test_examples and two_image is None:
if mnist.test.labels[index][2] == 1:
two_image = mnist.test.images[index].reshape(1, 784)
two_onehot = mnist.test.labels[index].reshape(1, 10)
index += 1
six_onehot = None
index = 0
while index < num_test_examples and six_onehot is None:
if mnist.test.labels[index][6] == 1:
six_onehot = mnist.test.labels[index].reshape(1, 10)
index += 1
np_grad = sess.run(grad,
feed_dict={
x: two_image,
y_: six_onehot,
keep_prob: 1.0
})
signed_grad = numpy.sign(np_grad[0])
delta_image_unsigned = 0.1 * np_grad[0]
delta_image = 0.01 * signed_grad
adv_image = delta_image + two_image
print sess.run(y_conv, feed_dict={x: two_image, keep_prob: 1.0})
print two_onehot
print six_onehot
print sess.run(y_conv, feed_dict={x: adv_image, keep_prob: 1.0})
cnn_utils.save_image(np_grad[0], 'unsigned_grad')
cnn_utils.save_image(signed_grad, 'signed_grad')
cnn_utils.save_image(delta_image_unsigned, 'delta_image_unsigned')
cnn_utils.save_image(delta_image, 'delta_image')
cnn_utils.save_image(adv_image, 'adv_image')
cnn_utils.save_image(two_image, 'two_image')
print two_image
print delta_image
print adv_image
sess.close()