def run_episode(self):
(s, r, d) = self.mario_env.reset()
counter = 0
while True:
time.sleep(
THREAD_DELAY
) # so that multiple agents can run in parallel (more then cpus)
try:
im = self.get_screenshot(s)
im = self.prepare_image(im)
a = self.agent.act(im)
s_, r, done = self.mario_env.step(a)
im_ = utils.get_screenshot(s_)
im_ = utils.prepare_image(im_)
if not done:
self.agent.train(im, a, r, im_)
s = s_
except:
print(
'some error occured during image processing use default action'
)
print(sys.exc_info()[0])
a = 0
if counter == 300:
(s, r, d) = self.mario_env.reset()
counter = 0
global frames
frames = 0
counter += 1
if done or self.stop_signal:
break
def predict():
"""initialize the data dictionary that will be returned from the
view
:rtype: `flask.json`
"""
global model, graph
data = {"success": False}
# ensure an image was properly uploaded to our endpoint
if flask.request.method == "POST":
if flask.request.files.get("image"):
# read the image in PIL format
image = flask.request.files["image"].read()
image = Image.open(io.BytesIO(image))
# preprocess the image and prepare it for classification
image = prepare_image(image=image, target_size=TARGET_SIZE)
# classify the input image and then initialize the list
# of predictions to return to the client
#run predictions asynchronously and get output with collect()
with graph.as_default():
preds = model.predict(image)
data["predictions"] = preds
# indicate that the request was a success
data["success"] = True
# return the data dictionary as a JSON response
return flask.jsonify(data)
def run(self) -> None:
while True:
# remove stale memes
for file in Path('images/').glob('*'):
if arrow.get(
file.stat().st_mtime) > arrow.now().shift(hours=+1):
os.remove(file)
# get next meme
post = next(self._reddit_d.subreddit('memes').new(limit=1))
skip = False
for img in self._images:
if img.caption == post.title:
os.remove(img.path)
skip = True
if skip:
continue
# download the maymay
r = requests.get(post.url, stream=True)
if r.status_code != 200:
time.sleep(self._timeout / 2)
continue
r.raw.decode_content = True
tmp_path = utils.save_image(r.raw)
path = utils.prepare_image(tmp_path)
self.images.append(_Image(path, post.title))
time.sleep(self._timeout)
def image_feature_recognition(image_path):
display_ui_image(image_path, 224, 224)
image224 = prepare_image(image_path, 224, 224)
image299 = prepare_image(image_path, 299, 299)
image331 = prepare_image(image_path, 331, 331)
set_text('')
add_text(VGG16_predict(image224))
add_text(VGG19_predict(image224))
add_text(ResNet50_predict(image224))
add_text(InceptionV3_predict(image299))
add_text(Xception_predict(image299))
add_text(MobileNet_predict(image224))
add_text(MobileNetV2_predict(image224))
add_text(DenseNet_predict(image224))
add_text(NASNetLarge_predict(image331))
add_text(NASNetMobile_predict(image224))
def do_GET(self):
### determine manual override
manual_override = real_controller.manual_override()
if (not manual_override):
## Look
bmp = take_screenshot()
vec = prepare_image(bmp)
## Think
joystick = model.y.eval(session=sess,
feed_dict={
model.x: [vec],
model.keep_prob: 1.0
})[0]
else:
joystick = real_controller.read()
joystick[
1] *= -1 # flip y (this is in the config when it runs normally)
## Act
### calibration
output = [
int(joystick[0] * 80),
int(joystick[1] * 80),
int(round(joystick[2])),
int(round(joystick[3])),
int(round(joystick[4])),
]
### print to console
if (manual_override):
cprint("Manual: " + str(output), 'yellow')
else:
cprint("AI: " + str(output), 'green')
### respond with action
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write(output)
return
def act(self, screenshot_path, reward, done):
action = None
im = utils.get_screenshot(screenshot_path)
if im is not None:
prepared_image = utils.prepare_image(im)
action = self.model.predict(prepared_image, batch_size=1)[0]
action = action[0]
else:
logger.error(
'If you want image from clipboard, provide image in clipboard')
if action is None:
logger.error(
'could not predict next action set action=0 | screenshot path: {}'
.format(screenshot_path))
return 0
return action
def seek(net, filename):
"""
Loading image and return list of Result objects
"""
full_img = pl.imread(filename)
#img = full_img
img = full_img[:full_img.shape[0] // 4, :full_img.shape[1] // 4]
if img.dtype == np.uint8:
img = img.astype(np.float32) / 255.0
img_size = float(img.shape[0] * img.shape[1])
lum = get_lum(img)
edges = canny(lum, sigma=config.seek.lum_sigma)
fill = ndimage.binary_fill_holes(edges)
fill = remove_small_objects(fill, 100)
labels, n = ndimage.label(fill)
for y, x in (t for t in ndimage.find_objects(labels) if t is not None):
# where = np.argwhere(labeled == i)
# s - start, e- end
width = float(x.start - x.stop)
height = float(y.start - y.stop)
size = width * height / img_size
ratio = width / height
# print '%5.2f%% %5.2f' % (size * 100, ratio)
if not (config.seek.size.in_range_close(size)
and config.seek.ratio.in_range_close(ratio)):
continue
shape = img[y, x]
prepared_img = prepare_image(shape, size=config.image.size)
result = net.activate(prepared_img)
yield Result(shape,
sorted(((image_names[i], x)
for i, x in enumerate(result)),
key=lambda a: -a[1]))
def predict():
"""initialize the data dictionary that will be returned from the
view
:rtype: `flask.json`
"""
global model, graph
data = {"success": False}
# ensure an image was properly uploaded to our endpoint
if flask.request.method == "POST":
if flask.request.files.get("image"):
# read the image in PIL format
image = flask.request.files["image"].read()
image = Image.open(io.BytesIO(image))
# preprocess the image and prepare it for classification
image = prepare_image(image=image, target_size=TARGET_SIZE)
# classify the input image and then initialize the list
# of predictions to return to the client
#run predictions asynchronously and get output with collect()
with graph.as_default():
preds = model.predict(image)
print(flask.request.args)
if flask.request.args.get("top"):
top = flask.request.args.get("top")
results = imagenet_utils.decode_predictions(preds, top=top)
else:
results = imagenet_utils.decode_predictions(
preds, top=DEFAULT_PREDICTION_NUMBER)
data["predictions"] = []
# loop over the results and add them to the list of
# returned predictions
for (imagenetID, label, prob) in results[0]:
r = {"label": label, "probability": float(prob)}
data["predictions"].append(r)
# indicate that the request was a success
data["success"] = True
# return the data dictionary as a JSON response
return flask.jsonify(data)
def predict():
data = {"success": False}
if request.method == "POST":
if request.files.get("image"):
image = request.files["image"].read()
try:
image = prepare_image(image)
except Exception:
logging.exception("Error in preparing image")
return jsonify(data), 400
im_id = str(uuid4())
im_dict = {"im_id": im_id, "image": b64_encoding(image)}
# send image to the redis queue
db.rpush(IMAGE_QUEUE, json.dumps(im_dict))
logging.info("New image added to queue with id: %s", im_id)
while True:
# start polling
output = db.get(im_id)
if output is not None:
# image processed, try to get predictions
try:
output = output.decode("utf-8")
data["predictions"] = json.loads(output)
logging.info("Got predictions for image with id: %s",
im_id)
except Exception:
logging.exception(
"Error in getting predictions for image with id: %s",
im_id)
return jsonify(data), 400
finally:
db.delete(im_id)
logging.info("Deleting image from queue with id: %s",
im_id)
break
time.sleep(CONSUMER_SLEEP)
data["success"] = True
logging.info("Send result for image with id: %s", im_id)
return jsonify(data), 200
logging.warning("Invalid request with file %s", request.files)
return jsonify(data), 400
def predict(image_path, model_path, top_k, class_names_path):
image = utils.prepare_image(image_path)
model = utils.load_model(model_path)
# Predict
predictions = model.predict(image)[0]
# Get indexes of top k predictions
# Sort indexes, in reverse (descending) order
sorted_indexes = np.argsort(predictions)[::-1]
top_k_indexes = sorted_indexes[0:top_k]
# Extract probabilites and class names based on indexes
probabilities = [predictions[i] for i in top_k_indexes]
if class_names_path != None:
# +1 because class_names key range is from 1 to 102
class_names = utils.load_class_names(class_names_path, top_k_indexes)
else:
# Put indexes for class names
class_names = [i for i in range(1, 103)]
return class_names, probabilities
score = mad(x, y)
return score.mean()
else:
with torch.no_grad():
score = mad(x, y)
return score
if __name__ == '__main__':
from PIL import Image
import argparse
from utils import prepare_image
parser = argparse.ArgumentParser()
parser.add_argument('--ref', type=str, default='images/r0.png')
parser.add_argument('--dist', type=str, default='images/r1.png')
args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
ref = prepare_image(Image.open(args.ref).convert("L"),
repeatNum=1).to(device)
dist = prepare_image(Image.open(args.dist).convert("L"),
repeatNum=1).to(device)
model = MAD(channels=1).to(device)
score = model(dist, ref, as_loss=False)
print('score: %.4f', score.item())
# score: 168
return score
if __name__ == '__main__':
from PIL import Image
import argparse
from utils import prepare_image
parser = argparse.ArgumentParser()
parser.add_argument('--ref', type=str, default='images/r0.png')
parser.add_argument('--dist', type=str, default='images/r1.png')
args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
ref = prepare_image(Image.open(args.ref).convert("RGB")).to(device)
dist = prepare_image(Image.open(args.dist).convert("RGB")).to(device)
model = SSIM(channels=3)
score = model(dist, ref, as_loss=False)
print('score: %.4f' % score.item())
# score: 0.6717
# model = SSIM(channels=1)
# score = 0
# for i in range(3):
# ref1 = ref[:,i,:,:].unsqueeze(1)
# dist1= dist[:,i,:,:].unsqueeze(1)
# score = score + model(ref1, dist1).item()
# print('score: %.4f' % score)
def do_GET(self):
global gas
### determine manual override
manual_override = real_controller.manual_override()
if (not manual_override):
## Look
image = take_screenshot()
vec = prepare_image(image)
## Think
joystick = model.y.eval(session=sess, feed_dict={model.x: [vec], model.keep_prob: 1.0})[0]
steer = joystick[0]
print steer
gas = 1 - gas
# gas = 1
# joystick[1] = gas # slow down a bit
####### amplification
# steer = amp(int(steer * 80))
steer = int(steer * 80)
# print steer
Y_axis = 0
else:
joystick = real_controller.read()
joystick[1] *= -1 # flip y (this is in the config when it runs normally)
steer = int(joystick[0] * 80)
gas = int(joystick[2])
Y_axis = int(joystick[1] * 80)
# joystick[1] = 0 # Y axis
# joystick[3] = 0 # X button
# joystick[4] = 0 # RB button
## Act
output = [
steer,
gas,
Y_axis
# joystick[0], # LEFT RIGHT ANALOG
# joystick[1], # UP DOWN ANALOG
# joystick[2], # A
# joystick[3], # X
# joystick[4], # RB
]
### print to console
if (manual_override):
cprint("Manual: " + str(output), 'yellow')
else:
cprint("AI: " + str(output), 'green')
# TODO: include other buttons as in controller.c (input-bot)
json_output = ControllerState()
json_output.X_AXIS = steer
json_output.Y_AXIS = Y_axis
json_output.A_BUTTON = gas
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write(json.dumps(json_output.__dict__))
return
def predict():
# initialize the data dictionary that will be returned from the
# view
data = {"success": False}
# ensure an image was properly uploaded to our endpoint
if flask.request.method == "POST":
if flask.request.files.get("image"):
# read the image in PIL format and prepare it for
# classification
image = flask.request.files["image"].read()
image = Image.open(io.BytesIO(image))
image = prepare_image(image, (IMAGE_WIDTH, IMAGE_HEIGHT))
# reading the task choice
task = flask.request.form["task"]
# ensure our NumPy array is C-contiguous as well,
# otherwise we won't be able to serialize it
# image = image.copy(order="C")
# generate an ID for the classification then add the
# classification ID + image to the queue
k = str(uuid.uuid4())
d = {"id": k, "image": image, "type": task}
db.rpush(IMAGE_QUEUE, json.dumps(d))
# keep looping until our model server returns the output
# predictions
while True:
# attempt to grab the output predictions
output = db.get(k)
# check to see if our model has classified the input
# image
if output is not None:
# add the output predictions to our data
# dictionary so we can return it to the client
if task == 'IMC':
output = output.decode("utf-8")
data["predictions"] = json.loads(output)
data["type"] = 'IMC'
elif task == 'IMT':
output = output.decode("utf-8")
data["result"] = str.replace(
str.replace(output, '\n', '<br>'), 'temp.jpeg', '')
data["type"] = 'IMT'
elif task == 'ODT':
output = base64_encode_image(output)
data["result"] = output
data["type"] = 'ODT'
# delete the result from the database and break
# from the polling loop
db.delete(k)
break
# sleep for a small amount to give the model a chance
# to classify the input image
time.sleep(CLIENT_SLEEP)
# indicate that the request was a success
data["success"] = True
# return the data dictionary as a JSON response
return flask.jsonify(data)
# собираем ядро
mod = compiler.SourceModule(open("kernel.cu", "r").read())
bilinear_interpolation_kernel = mod.get_function("interpolate")
x_out = np.array([i for i in range(M2)] * N2)
y_out = np.array([i for i in range(N2)] * M2)
start = driver.Event()
stop = driver.Event()
#подготовка текстуры
print("Считаем на ГПУ...")
start.record()
prep_image = prepare_image(image)
tex = mod.get_texref("tex")
tex.set_filter_mode(driver.filter_mode.LINEAR)
tex.set_address_mode(0, driver.address_mode.CLAMP)
tex.set_address_mode(1, driver.address_mode.CLAMP)
driver.matrix_to_texref(prep_image, tex, order="C")
bilinear_interpolation_kernel(driver.Out(result),
driver.In(x_out),
driver.In(y_out),
np.int32(M1),
np.int32(N1),
np.int32(M2),
np.int32(N2),
block=block,
grid=grid,
cord = cords[tvname]
img_cords = (slice(cord[1], cord[1] + cord[3]),
slice(cord[0], cord[0] + cord[2]))
for fname in names:
# load file
name = test_dir_name + fname
img = imread(name)
# get logo
box = img[img_cords]
fig = pl.figure('logo_%s' % fname.split('.')[0].replace(' ', '_'))
# create image
prepared_img = prepare_image(box, size=config.image.size)
# simulate
result = net.activate(prepared_img)
# result
min_result = min(result)
delta = max(result) - min_result
result = sorted(((image_names[i], x)
for i, x in enumerate(result)),
key=lambda a: -a[1])
fig = pl.figure()
fig.add_subplot(1, 2, 1).imshow(img)
import utils
import Parameters
import model
import numpy as np
import matplotlib.pyplot as plt
_, parameters = Parameters.load_last()
classes = [
"without_mask",
"with_mask",
]
Test_Image = r'tdataset\prepared\dev\1-0185.png'
real_image = utils.prepare_image(Test_Image, image_size=64)
image = real_image.copy()
image_flatten = image.reshape(1, -1).T
image = image_flatten / 255.
p, _ = model.predict(image, np.array([[0]]), parameters)
plt.imshow(real_image, interpolation='nearest')
plt.title(f'predict: {classes[int(np.squeeze(p))]}')
plt.axis('off')
plt.show()
landmark_file = open(landmark)
lines = landmark_file.readlines()
landmark = []
for line in lines:
elem = line.strip()
elem = elem.split(' ')
landmark.append([float(i) for i in elem])
landmarks.append(landmark)
maximum = np.amax(landmark, axis=0)
minimum = np.amin(landmark, axis=0)
bb = np.concatenate([minimum, maximum], 0)
new_im, _ = prepare_image(im, bb, shape=(224, 224), convert_shape=True)
# cv2.imshow(f'{frame}', new_im)
# cv2.waitKey(1)
# cv2.destroyAllWindows()
new_im = cv2.cvtColor(new_im, cv2.COLOR_BGR2RGB)
new_im = new_im.astype(np.float32)/255
cropped_frames.append(new_im)
label_file = open(os.path.join(label_dir, subject, folder, label_list[0]))
label = label_file.read()
label = label.strip()
label = int(float(label))
features = intermediate_layer_model.predict(np.asarray(cropped_frames))
# print(features.shape)
def predict_btn_listener(event):
app.enable_buttons(False)
app.save_image(utils.get_cwd() + "/.keras/images/orig_image.ps")
utils.prepare_image(utils.get_cwd() + "/.keras/images/orig_image.ps")
model.predict(utils.get_cwd() + "/.keras/images/prepared_image.png", predict_btn_callback)
targets = np.zeros((0, 2))
for frame in frames:
counter += 1
frame_dir = os.path.join(dataset_dir, folder, subject, frame)
im = cv2.imread(frame_dir)
landmarks = subject_info['frames'][f'{frame[:-4]}']['landmarks']
arousal = subject_info['frames'][f'{frame[:-4]}']['arousal']
valence = subject_info['frames'][f'{frame[:-4]}']['valence']
maximum = np.amax(landmarks, axis=0)
minimum = np.amin(landmarks, axis=0)
bb = np.concatenate([minimum, maximum], 0)
try:
new_im, _ = prepare_image(cv2.cvtColor(im, cv2.COLOR_BGR2RGB),
bb,
shape=(224, 224),
convert_shape=True)
except:
print('error')
print(subject)
print(frame)
input_images = np.vstack(
(input_images, new_im[np.newaxis, :, :, :]))
targets = np.vstack((targets, np.array([[valence, arousal]])))
# for i in range(input_images.shape[0]):
# pic = input_images[i, :, :, :].astype(np.uint8)
# cv2.imshow(f'frame', pic)
# cv2.waitKey(50)
input_images = input_images / 255
