def do_GET(self):
"""
Testing tensorflow
"""
classify_image.run_inference_on_image('x.jpg')
f = self.send_head()
if f:
self.copyfile(f, self.wfile)
f.close()
def handle(msg):
if msg["photo"]:
chat_id = msg['chat']['id']
f = tempfile.NamedTemporaryFile(delete=True).name + ".png"
photo = msg['photo'][-1]["file_id"]
bot.download_file(photo, f)
prediction = classify_image.run_inference_on_image(f)
bot.sendMessage(chat_id, "I think this image is a %s" % prediction)
else:
print("no photo")
def handle_file():
if request.method == 'POST':
f = request.files['file']
im = Image.open(f)
rgb_im = im.convert('RGB')
rgb_im.save('tmp.jpg')
answer = cfi.run_inference_on_image('tmp.jpg')
print(answer)
# print(os.path.join(os.path.dirname(__file__),'tmp.jpg'))
return jsonify(status="OK", human=answer[0], score=str(answer[1]))
else:
return jsonify(status="ERROR")
def find_objects_in_sections(image,num_crops):
"""Function that does finer grained object recognition by cropping the image into several sections"""
r_step, c_step = image.shape[0]//num_crops, image.shape[1]//num_crops
object_list = []
for i in range(num_crops):
for j in range(num_crops):
tf.reset_default_graph()
cropped_image = image[i*r_step:(i+1)*r_step,j*c_step:(j+1)*c_step,:]
inf_list = ci.run_inference_on_image(cropped_image)
if inf_list != []:
object_list.extend(inf_list)
return object_list
def image_vector(img_file):
img_data = classify_image.run_inference_on_image(img_file)
print(img_data)
tags = img_data['results'][0]['result']['tag']['classes']
weights = img_data['results'][0]['result']['tag']['probs']
vector = [0] * current_index
for i in range(len(tags)):
if tags[i] in tag_indices:
vector[tag_indices[tags[i]]] = weights[i]
return vector
def handler(event, context):
bucket = TEMP_BUCKET_NAME
key = event['key']
lambda_id = 1
image_id = get_time_from_id(lambda_id)
video_name = '{}{}'.format(uuid.uuid4(), key)
download_path = '/tmp/%s' % video_name
s3_client.download_file(bucket, key, download_path)
log = grab_frame(download_path, image_id, logger)
(infer, times) = run_inference_on_image(get_image_name(image_id), logger)
cleanup_files(download_path, get_image_name(image_id))
output_file = video_name.split(".")[0] + ".txt"
open("/tmp/" + output_file, "w+").write(infer)
s3_client.upload_file("/tmp/" + output_file, bucket, output_file)
return {'output_key': output_file}
def handler(event, context):
bucket = TEMP_BUCKET_NAME
key = event['key']
lambda_id = 1
image_id = get_time_from_id(lambda_id)
video_name = '{}{}'.format(uuid.uuid4(), key)
download_path = '/tmp/%s' % video_name
s3_client.download_file(bucket, key, download_path)
log = grab_frame(download_path, image_id, logger)
(infer,times) = run_inference_on_image(get_image_name(image_id), logger)
cleanup_files(download_path, get_image_name(image_id))
output_file = video_name.split(".")[0] + ".txt"
open("/tmp/" + output_file, "w+").write(infer)
s3_client.upload_file("/tmp/" + output_file, bucket, output_file)
return {'output_key' : output_file}
def inference(file_name):
try:
predictions, top_k, top_names = run_inference_on_image(file_name)
print(predictions)
except Exception as ex:
print(ex)
return ""
new_url = '/static/%s' % os.path.basename(file_name)
image_tag = '<img src="%s" width="200" height="200"></img><p>'
new_tag = image_tag % new_url
format_string = ''
for node_id, human_name in zip(top_k, top_names):
score = predictions[node_id]
format_string += '%s (score:%.5f)<BR>' % (node_id, score)
ret_string = new_tag + format_string + '<BR>'
return ret_string
def predict(self, quote):
logger.info(
'---------------------------PREDICT---------------------------------'
)
logger.info(quote.symbol)
df = self.price_arr[quote.symbol]
low_list = df['low'].rolling(
window=9, center=False).min() # pd.rolling_min(df['low'], n)
low_list.fillna(value=df['low'].expanding(min_periods=1).min(),
inplace=True)
high_list = df['high'].rolling(
window=9, center=False).max() # pd.rolling_max(df['high'], n)
high_list.fillna(value=df['high'].expanding(min_periods=1).max(),
inplace=True)
rsv = (df['close'] - low_list) / (high_list - low_list) * 100
df['k'] = pd.ewma(rsv, com=2)
df['d'] = pd.ewma(df['k'], com=2)
df['j'] = 3.0 * df['k'] - 2.0 * df['d']
close = [float(x) for x in df['close']]
# prepare macd data
df['MACD'], df['MACDsignal'], df['MACDhist'] = talib.MACD(
np.array(close), fastperiod=12, slowperiod=26, signalperiod=9)
#上新
if len(df.index) < 42:
return
# 停牌
if df.iloc[-3, 0] == 0 or df.iloc[-2, 0] == 0 or df.iloc[-1, 0] == 0:
return 0
j = df['j']
df['norm_j'] = j.apply(lambda x: (x - j.mean()) / (j.std()))
bar_value = df['MACDhist'] * 2
# print(df)
df['norm_bar'] = bar_value.apply(lambda x: (x - bar_value.mean()) /
(bar_value.std()))
pic_path = self.create_macd_j_pic(quote.symbol, df[-3:],
self.window_count)
result = run_inference_on_image(pic_path)
logger.info(result)
logger.info(
'-------------------------------------------------------------------\n'
)
return result
def recognizeObject(self):
print "getting image"
self.getAndSaveImage(self.img_name)
# classify image
print "getting classification"
res = classifier.run_inference_on_image(self.img_name)[0]
print res
if type(res) == dict:
#get label with highest probabilty
label = res["label_name"].split(",")[0]
prob = str(int(res["score"]*100))
return [label,prob]
else:
print "result type is not a dict"
return None
def recognizeObject(self):
print "getting image"
self.getAndSaveImage(self.img_name)
# classify image
print "getting classification"
res = classifier.run_inference_on_image(self.img_name)[0]
print res
if type(res) == dict:
#get label with highest probabilty
label = res["label_name"].split(",")[0]
prob = str(int(res["score"] * 100))
return [label, prob]
else:
print "result type is not a dict"
return None
def post(self):
file1 = self.request.files['file1'][0]
original_fname = file1['filename']
file_body = file1['body']
extension = imghdr.what('', file_body)
if extension not in ALLOWED_EXTENSIONS:
print("Not a valid filetype")
self.redirect("/")
else:
fname = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(6))
final_filename = fname+'.'+extension
file_path = os.path.join(uploads_dir, final_filename)
output_file = open(file_path, 'wb')
output_file.write(file_body)
output_file.close()
img = base64.b64encode(file_body)
values = run_inference_on_image(file_path, FLAGS)
self.render('prediction.html', filename=final_filename, img=img, values=values)
def updateText(self):
global native
conn = sqlite3.connect('sqlitedb.db')
c = conn.cursor()
image = PATH_TO_IMG + str(self.timeStamp) + ".jpg"
label, clevel = cl.run_inference_on_image(image)
# Take the first word of the first line and translate it
tuple = label.partition(',')
label = str(tuple[0])
c.execute(
'SELECT spanishW, definition, englishP, spanishP FROM translation where (?) = englishW',
(label, ))
all_rows = c.fetchall()
trans = ""
defin = ""
engPhrase = ""
spnPhrase = ""
for row in all_rows:
trans = str(row[0])
defin = str(row[1])
engPhrase = str(row[2])
spnPhrase = str(row[3])
if spnPhrase == "espPhrase":
spnPhrase = None
if engPhrase == "engPhrase":
engPhrase = None
if native == "english":
self.translatedWord = trans
self.objectLabel = "Translation of \'" + label + "\': " + trans + "\nDefinition: " + defin + "\nEnglish Phrase: " + engPhrase + "\nSpanish Phrase: " + spnPhrase
elif native == "spanish":
self.translatedWord = label
self.objectLabel = "Traducción de: \'" + trans + "\': " + label + "\nFrase en Español: " + spnPhrase + "\nFrase Inglesa: " + engPhrase
CameraScreen.insertObjectIntoHistoryDB(label, clevel, trans,
self.timeStamp)
return
for key in image_to_question:
print image_to_question[key][0][image_to_question[key][0][1] + 1]
print image_to_question[key][0][len(image_to_question[key][0])-1]
assert 2==1,'stop'
'''
dirs = os.listdir(train_image_path)
image_list = []
image_id = []
for number in xrange(100):
nos = 0
for key in image_to_question:
image_list.append(train_image_path+'/'+'COCO_train2014_000000'+key+'.jpg')
image_id.append(key)
if len(image_list) == 10:
conv_array = classify_image.run_inference_on_image(image_list)
sess = tf.Session()
saver.restore(sess,'my-model-0')
#sess.run(tf.initialize_all_variables())
costs = 0
for i in xrange(len(image_id)):
this_image_id = image_id[i]
for j in xrange(len(image_to_question[this_image_id])):
costs = sess.run([cost,train_step],feed_dict={conv_feature:conv_array[i],question:image_to_question[this_image_id][j][2],answer:image_to_question[this_image_id][j][-1]})[0]
if costs != costs:
print image_to_question[this_image_id][j][0]
print image_to_question[this_image_id][j][1]
print image_to_question[this_image_id][j][2 + image_to_question[this_image_id][j][1]]
print ss[0]
print image_to_question[this_image_id][j][-1]
for msg in consumer:
# deserialize from json
twete = jsonpickle.decode(msg.value)
# for each media object in tweet
for media in twete.entities['media']:
# base64 jpg string to bytes
image_data = base64.b64decode(media['data'])
# make sure image is jpeg
if is_jpg(image_data) == False:
print("Invalid panda {0}".format(msg.offset))
continue
# run tensorflow image recognition
predictions, top_k = run_inference_on_image(image_data)
# determine if there is a panda match, if so how good the match is (score should be > 0.5)
for node_id in top_k:
# giant panda = 169
# red panda = 7
# human_string = node_lookup.id_to_string(node_id)
score = predictions[node_id]
if node_id in [7, 169] and score > 0.5:
# WE HAVE PANDA
media['panda_node_id'] = str(node_id)
producer.send("Panda_Image_Tweets", jsonpickle.encode(twete).encode('UTF-8'), str(twete.id).encode('UTF-8'))
break
import classify_image as classifier
# only required for the example image
import os
import tensorflow as tf
#FLAGS = tf.app.flags.FLAGS
if __name__ == '__main__':
print("all labels:", classifier.all_labels())
example_image_path = tf.app.flags.FLAGS.model_dir
print("example_image_path:", example_image_path)
image = os.path.join(example_image_path, 'cropped_panda.jpg')
print(classifier.run_inference_on_image(image)[0])
#image2 = "220px-Binturong_in_Overloon.jpg"
#print(classifier.run_inference_on_image(image2)[0])
#image3 = "6a010535647bf3970b016765cbf839970b-500wi.jpg"
#print(classifier.run_inference_on_image(image3)[0])
def run_locally(image_url):
results = classify_image.run_inference_on_image(image_url)
# import the necessary packages from picamera.array import PiRGBArray from picamera import PiCamera import time import cv2 import classify_image import os # initialize the camera and grab a reference to the raw camera capture camera = PiCamera() rawCapture = PiRGBArray(camera) # allow the camera to warmup time.sleep(0.1) # grab an image from the camera camera.capture(rawCapture, format="bgr") img = rawCapture.array BUFFER_DIR = '/var/hamster' img = cv2.resize(img, (128, 96)) img_file = os.path.join(BUFFER_DIR, str(time.time()) + '.jpg') cv2.imwrite(img_file, img) classify_image.maybe_download_and_extract() classify_image.run_inference_on_image(img_file) #os.remove(img_file)
def predict(image):
ci.run_inference_on_image(image)
import classify_image as CI
import pandas as pd
from sys import argv
'''
Takes two numerical values as input from the system
Puts them through the tensorflow classifier
Returns pandas dataframe
Merge_flag indicates if it is the last index and should merge all files together
'''
###### System arguments #######
num1 = int(argv[1])
num2 = int(argv[2])
mergeFLAG = argv[3]
###### specifies username and directory #######
username = '******'
dir_name = 'data/' + username + '/'
###### Runs the classification #######
temp = pd.read_csv('temp.csv')
temp2 = CI.run_inference_on_image(num1, num2)
temp = pd.concat([temp, temp2], ignore_index=True)
temp.to_csv('temp.csv', index=False)
###### Merges all data into one csv #######
if mergeFLAG == 'True':
instagram = pd.read_csv(dir_name + username + '_complete.csv')
instagram = pd.concat([instagram, temp], axis=1)
instagram.to_csv('instagram_temp.csv', index=False)
def get(self, bucket_name, object_name):
s3_img = get_file(bucket_name, object_name)
return run_inference_on_image(s3_img.read())
def register_account():
access_token = request.json['token']
user_id = request.json['user_id']
founduser = users.find_one({"user_id": user_id})
target = open('tokens.txt', 'a')
target.write(
strftime("%Y-%m-%d %H:%M:%S", gmtime()) + ' token: ' + access_token +
' user_id: ' + user_id + '\n')
if not access_token:
return 'Missing access token'
session['access_token'] = access_token
session['user_id'] = user_id
if not founduser:
api = InstagramAPI(access_token=access_token,
client_secret=IG_CLIENT_SECRET)
recent_media, next_ = api.user_recent_media(user_id=user_id, count=20)
tags = []
num_likes = []
dates = []
time_of_day = []
weights = []
global recurring
global pictures
# Convert all images to vectors
for media in recent_media:
img_data = classify_image.run_inference_on_image(
media.images['standard_resolution'].url)
tags.append(img_data['results'][0]['result']['tag']['classes'])
weights.append(img_data['results'][0]['result']['tag']['probs'])
recurring.append(
img_data['results'][0]['result']['tag']['classes'])
date = int(media.created_time.strftime("%s")) * 1000
dates.append(date)
time_of_day.append(media.created_time.hour)
num_likes.append(media.like_count)
pictures.append([
media.images['standard_resolution'].url,
img_data['results'][0]['result']['tag']['classes']
])
# Dictionary to store indices of tags
global tag_indices
# Iterator for indices
global current_index
for vector in tags:
for tag in vector:
if tag not in tag_indices:
tag_indices[tag] = current_index
reverse_tag_indices.append(tag)
current_index += 1
data = []
# Importances of tags
tag_scores = {}
# Number of images in which tags appear
tag_count = {}
# Generate vectors for each image by marking each tag with weight
for i in range(len(tags)):
vector = [0] * current_index
for j in range(len(tags[i])):
vector[tag_indices[tags[i][j]]] = weights[i][j]
if tags[i][j] in tag_scores:
tag_scores[tags[i][j]] += weights[i][j] * num_likes[i]
tag_count[tags[i][j]] += 1
else:
tag_scores[tags[i][j]] = weights[i][j] * num_likes[i]
tag_count[tags[i][j]] = 1
# Append extra variables and number of likes
vector.append(dates[i])
vector.append(time_of_day[i])
vector.append(num_likes[i])
data.append(vector)
# Divide tag scores by number of pictures they appear in
for key, value in tag_scores.iteritems():
# Maximize score if tag is in 5 pictures
tag_scores[key] /= 5 + abs(5 - tag_count[key])
sorted_tag_scores = sorted(tag_scores.items(),
key=operator.itemgetter(1),
reverse=True)
# Top ten most important tags
top_ten_tags = []
for elem in sorted_tag_scores[:10]:
top_ten_tags.append([elem[0], elem[1]])
userid = users.insert_one({
'user_id': user_id,
'recurring': recurring,
'topten': top_ten_tags,
'pictures': pictures,
'data': data,
'current_index': current_index,
'tag_indices': tag_indices
})
toreturn = users.find_one({"user_id": user_id})
response = json.dumps(toreturn,
sort_keys=True,
indent=4,
default=json_util.default)
pictures = []
recurring = []
top_ten_tags = []
sorted_tags = []
global model
model = LikePredictor(toreturn['data'])
return response
def lookup_image(image_file_path='image.jpg'):
classify_image.maybe_download_and_extract()
classify_image.run_inference_on_image(image_file_path)
with open("./fall11_urls_first_2000.txt","r") as f:
whole_file = f.read().split("\n")
ltime = []
for idx_image in range(number_images):
cimage_url = whole_file[0].split("\t")[1]
cimage_label = whole_file[0].split("\t")[0]
print(cimage_url)
tic()
#url = url_base + cimage_url
#r = requests.post(url)
classify_image.run_inference_on_image(cimage_url)
#dd = r.json()
ltime.append(toc_time())
print(ltime)
#print(idx_image, dict_labels[cimage_label.split("_")[0]], dd)
if False:
"""
First attempt, in case that the graph needs to be generated again
"""
ltime = [26.585001230239868, 5.283040523529053, 17.73598027229309, 2.593003749847412, 11.248939037322998, 2.8200619220733643, 16.670985221862793, 3.09599232673645, 11.502059698104858, 4.071980237960815, 5.934020519256592, 9.711987972259521, 3.0849857330322266, 9.33296251296997, 14.225001096725464, 2.841944694519043, 11.897971153259277, 8.175994634628296, 9.545000314712524, 9.329044342041016, 3.074040412902832, 16.126007795333862, 7.4029624462127686, 11.5600426197052, 3.250026226043701, 10.976969957351685, 3.347991943359375, 7.9989013671875, 16.665969133377075, 12.187048435211182, 3.6619510650634766, 9.953018426895142, 4.9029927253723145, 7.4029929637908936, 19.406497955322266, 3.731994390487671, 18.588664293289185, 9.653867244720459, 6.47782039642334, 19.050623893737793, 3.897918462753296, 19.40959143638611, 3.9949188232421875, 13.648678302764893, 3.9149134159088135, 11.525783777236938, 16.96566653251648, 12.292791366577148, 16.960097551345825, 4.2869017124176025]
plt.plot(ltime,'x-')
plt.xlabel("Attempt")
plt.ylabel("Time in seconds")
import core
import classify_image
import time
import json
run = True
while (run):
while (run):
message = core.checkTasks()
if "task" in message:
#core.downloadImage(message["task"])
string, score = classify_image.run_inference_on_image(
"images/" + str(message["task"]) + ".jpg")
result = {
"task": message["task"],
"result": string,
"score": float(score)
}
print(result)
core.sendMessageToFrontend(json.dumps(result))
else:
time.sleep(10)
def predict_top_5(image_url):
print("Tensorflow is processing the image...")
return run_inference_on_image(image_url)
import classify_image as inception
from os import remove
from os import listdir
from os.path import isfile, join
import shutil
import sys
import augment as aug
import types
import random
image_dir = 'data/cat'
images = [
f for f in listdir(image_dir)
if isfile(join(image_dir, f)) and not f.startswith('.') and (
(join(image_dir, f).endswith('.jpg')
or join(image_dir, f).endswith('.jpeg')))
]
for i, img in enumerate(images):
file_path = join(image_dir, img)
description = ''
with open(file_path, 'rb') as f:
description, score = inception.run_inference_on_image(f.read())
if 'cat' not in description:
remove(file_path)
else:
shutil.move(file_path, join(image_dir, 'checked'))
print 'done cleaning dataset'
import classify_image as classifier
# only required for the example image
import os
import tensorflow as tf
#FLAGS = tf.app.flags.FLAGS
if __name__ == '__main__':
print("all labels:", classifier.all_labels())
example_image_path = tf.app.flags.FLAGS.model_dir
print("example_image_path:", example_image_path)
image = os.path.join(example_image_path, 'cropped_panda.jpg')
print(classifier.run_inference_on_image(image)[0])
#image2 = "220px-Binturong_in_Overloon.jpg"
#print(classifier.run_inference_on_image(image2)[0])
#image3 = "6a010535647bf3970b016765cbf839970b-500wi.jpg"
#print(classifier.run_inference_on_image(image3)[0])