def get_prediction(content):
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/<>/locations/us-central1/models/<>'
payload = {'image': {'image_bytes': content}}
params = {}
request = prediction_client.predict(name, payload, params)
result_json = ast.literal_eval(
pf.json_format.MessageToJson(request,
including_default_value_fields=False))
try:
prediction = result_json["payload"][0]["displayName"]
except Exception as e:
prediction = "nothing"
return prediction
def predictClass(self, jpeg):
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
payload = {"image": {"image_bytes": jpeg}}
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
res = {}
for result in response.payload:
res[result.display_name] = result.classification.score
if result.display_name == "fall":
self.fall += 1
elif result.display_name == "stand":
self.stand += 1
# Uploading to storage
name = str(datetime.now()).replace(" ", "") + '.jpg'
blob = self.bucket.blob(name)
blob.upload_from_string(jpeg)
blob = self.bucket.blob(name.replace(".jpg", ".json"))
blob.upload_from_string(json.dumps(res))
if self.stand < 4 and self.stand > 0:
self.get_images(name,
"static/images/stand-0" + str(self.stand) + ".jpg")
print(name, res)
elif self.fall < 4 and self.fall > 0:
self.get_images(name,
"static/images/fall-0" + str(self.fall) + ".jpg")
print(name, res)
if self.fall > 4 and self.done:
self.done = False
account_sid = 'ACb7fcbdfdd696b6395691d777af1539b2'
auth_token = 'eb69fd893fb3d3f664692efcc16cbaa9'
client = Client(account_sid, auth_token)
message = client.messages \
.create(
body="EMERGENCY ALERT! We have detected that your contact has suffered a fall at "+str(datetime.now()),
from_='+14092456334',
to='+14803346945'
)
print(message.sid)
def get_prediction(content, project_id, model_id):
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format(
project_id, model_id)
payload = {'image': {'image_bytes': content}}
params = {}
#The response has the image classification and the confidence score for that image
response = prediction_client.predict(name, payload, params)
labels = response.payload # Get labels from response
#Get the classification of that image from labels
image_class = labels[0].display_name
#score_result has has the confidence score for that category
score_result = labels[0].classification
confidence = score_result.score
#print(labels)
return image_class, confidence # waits till request is returned
def predict(
project_id,
compute_region,
model_id,
file_path,
translation_allow_fallback=False,
):
"""Translate the content."""
# [START automl_translation_predict]
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
# translation_allow_fallback = True allows fallback to Google Translate
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(
project_id, compute_region, model_id
)
# Read the file content for translation.
with open(file_path, "rb") as content_file:
content = content_file.read()
content.decode("utf-8")
# Set the payload by giving the content of the file.
payload = {"text_snippet": {"content": content}}
# params is additional domain-specific parameters.
# translation_allow_fallback allows to use Google translation model.
params = {}
if translation_allow_fallback:
params = {"translation_allow_fallback": "True"}
response = prediction_client.predict(model_full_id, payload, params)
translated_content = response.payload[0].translation.translated_content
print(u"Translated content: {}".format(translated_content.content))
def get_prediction(content):
prediction_client = automl_v1beta1.PredictionServiceClient()
project_id='144025793143'
model_id='ICN8431156316856123392'
name = 'projects/{}/locations/us-central1/models/{}'.format(project_id, model_id)
payload = {'image': {'image_bytes': content }}
params = {}
request = prediction_client.predict(name, payload, params)
xs=str(request)
if "Happy" in xs:
speakText("Your pet is happy. You are doing a great job!")
elif "Sad" in xs:
speakText("Your pet is not emotionally well. Please take care")
elif "Anxious" in xs:
speakText("Your pet is stressed. Please give it some space, or let it go outside.")
def get_prediction_folder(folder_path, project_id, model_id):
"""Use model from GCP AutoML Vision to do inference and get results"""
time_a = time.time()
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format(
project_id, model_id)
params = {}
output = {}
f = []
time_b = time.time()
print("init_time: ", time_b - time_a, "(s)")
with open("confusion_matrix.txt", 'w+') as cf:
cf.write("Results: ")
cf.write("\n")
for (dirpath, dirnames, filenames) in os.walk(folder_path):
f.extend(filenames)
for dirname in dirnames:
label = dirname
for file in os.listdir(os.path.join(dirpath, dirname)):
time_c = time.time()
file_path = os.path.join(dirpath, dirname, file)
with open(file_path, 'rb') as ff:
content = ff.read()
payload = {'image': {'image_bytes': content}}
response = prediction_client.predict(name, payload, params)
for result in response.payload:
score = result.classification.score
predict_result = result.display_name
output['file_path'] = file_path
output['predict_result'] = predict_result
output['score'] = score
output['true_label'] = label
time_d = time.time()
output['inference_time'] = time_d - time_c
output_json = json.dumps(output)
outputs.append(output_json)
print(output_json)
with open("confusion_matrix.txt", 'a+') as cf:
cf.write(output_json)
cf.write("\n")
#break
return outputs
def processObjectDetection(self, base64_image):
self.content = base64_image
self.project_id = '125372421991'
self.model_id = 'IOD6167596126800183296'
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format(
self.project_id, self.model_id)
payload = {'image': {'image_bytes': self.content}}
params = {}
request = prediction_client.predict(name, payload, params).payload
if (len(request) > 0):
if (request[0].display_name == 'date'):
c1, c2 = request[
0].image_object_detection.bounding_box.normalized_vertices
nparr = np.fromstring(self.content, np.uint8)
img = cv.imdecode(nparr, cv.IMREAD_COLOR)
#img = cv.imread('renamed/'+f)
#img = cv.cvtColor(img,cv.COLOR_BGR2RGB)
width = img.shape[0]
height = img.shape[1]
x1 = int(c1.x * height)
y1 = int(c1.y * width)
x2 = int(c2.x * height)
y2 = int(c2.y * width)
retval, buffer = cv.imencode('.jpeg', img[y1:y2, x1:x2])
jpg_as_text = base64.b64encode(buffer)
return jpg_as_text
#imsave('crop.jpeg'+f,img[y1:y2,x1:x2])
else:
return None
else:
return None
def predict(image):
project_id = 'qualiscan-216706'
compute_region = 'us-central1'
model_id = 'ICN2956512205565128229'
score_threshold = '0.5'
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(
project_id, compute_region, model_id
)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
img_data = b64decode(image)
filename = 'some_image.jpg' # I assume you have a way of picking unique filenames
with open(filename, 'wb') as f:
f.write(img_data)
# Read the image and assign to payload.
with open(filename, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
results = []
for result in response.payload:
print(result)
results.append({"display_name": result.display_name,
"classification_score": result.classification.score})
# print("Predicted class name: {}".format(result.display_name))
# print("Predicted class score: {}".format(result.classification.score))
# print(response)
return results
def predict(project_id,
compute_region,
model_id,
file_path,
score_threshold=""):
"""Make a prediction for an image."""
# [START automl_vision_predict]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
# score_threshold = 'value from 0.0 to 0.5'
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
print("Predicted class name: {}".format(result.display_name))
print("Predicted class score: {}".format(result.classification.score))
def predict():
# TODO(developer): Uncomment and set the following variables
project_id = 'nutriscan'
compute_region = 'us-central1'
model_id = 'ICN6689485917993828352'
file_path = '/home/abdullahz/Desktop/food41/caesar_salad/70283.jpg'
score_threshold = '0.5'
from google.cloud import automl_v1beta1 as automl
import os
os.environ[
"GOOGLE_APPLICATION_CREDENTIALS"] = "./NutriScan-363118dbe915.json"
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
print("Predicted class name: {}".format(result.display_name))
print("Predicted class score: {}".format(result.classification.score))
return result.display_name
def analyze():
repeat_frequently()
global response_display_name
os.environ["GOOGLE_APPLICATION_CREDENTIALS"]="/home/pi/siteseer-030a672b14ba.json"
project = 'siteseer'
storage_client = storage.Client(project=project)
bucket = storage_client.get_bucket('siteseer')
automl_client = automl.AutoMlClient()
model_full_id = automl_client.model_path(
project_id, compute_region, model_id) # Get the full path of the model.
prediction_client = automl.PredictionServiceClient()
# repeat_frequently()
with open(file_path, "rb") as image_file:
content = image_file.read()
# repeat_frequently()
payload = {"image": {"image_bytes": content}}
params = { }
if score_threshold:
params = {"score_threshold": score_threshold}
# repeat_frequently()
response = prediction_client.predict(model_full_id, payload, params)
for result in response.payload:
touch_sensor()
print("Date: {} Prediction: {} {}".format(str(datetime.datetime.now()), result.display_name, result.classification.score))
if not result.display_name == response_display_name:
response_display_name = result.display_name
firebase.put('sight', 'speech/1', result.display_name)
# repeat_frequently()
image = bucket.blob('Sidewalk')
image.upload_from_filename('image.jpg')
def test_predict(self):
# Setup Expected Response
expected_response = {}
expected_response = prediction_service_pb2.PredictResponse(
**expected_response)
# Mock the API response
channel = ChannelStub(responses=[expected_response])
client = automl_v1beta1.PredictionServiceClient(channel=channel)
# Setup Request
name = client.model_path('[PROJECT]', '[LOCATION]', '[MODEL]')
payload = {}
response = client.predict(name, payload)
assert expected_response == response
assert len(channel.requests) == 1
expected_request = prediction_service_pb2.PredictRequest(
name=name, payload=payload)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def test_batch_predict_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name="operations/test_batch_predict_exception", done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = automl_v1beta1.PredictionServiceClient()
# Setup Request
name = client.model_path("[PROJECT]", "[LOCATION]", "[MODEL]")
input_config = {}
output_config = {}
response = client.batch_predict(name, input_config, output_config)
exception = response.exception()
assert exception.errors[0] == error
def AutoMlFunc(file_path):
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "..\**************"
project_id = '*************'
compute_region = 'us-central1'
model_id = 'ICN1060821442219325010'
score_threshold = '0'
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
# print("Prediction results:")
# for result in response.payload:
# print("Predicted class name: {}".format(result.display_name))
# print("Predicted class score: {}".format(result.classification.score))
return response.payload
def get_prediction(request):
request_json = request.get_json()
if request_json and 'content' in request_json:
content = request_json['content']
prediction_client = automl_v1beta1.PredictionServiceClient()
project_id = os.environ.get('PROJECT_ID', 'No Project ID is supplied')
model_id = os.environ.get('MODEL_ID', 'No Model ID is supplied')
name = 'projects/{}/locations/us-central1/models/{}'.format(
project_id, model_id)
payload = {'image': {'image_bytes': content}}
params = {}
request = prediction_client.predict(name, payload, params)
print(request)
return request # waits till request is returned
else:
return f'Pastikan data sudah benar'
def predict(project_id, compute_region, model_id):
project_id = "cdmx-safe-map"
compute_region = "us-central1"
model_id = "TCN3023487612629800943"
automl_client = automl.AutoMlClient()
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
text = request.form['comment']
document = types.Document(content=text,
type=enums.Document.Type.PLAIN_TEXT)
# Set the payload by giving the content and type of the file.
payload = {
"text_snippet": {
"content": document,
"mime_type": "text/plain"
}
}
# params is additional domain-specific parameters.
# currently there is no additional parameters supported.
params = {}
response = prediction_client.predict(model_full_id, payload, params)
labels = response.payload
#for result in response.payload:
#if(result.classification.score >0.6):
#print("{}".format(result.display_name))
#print("Predicted class score: {}".format(result.classification.score))
# [END automl_language_predict]
return render_template('homepage.html', text=text, labels=labels)
def test_batch_predict(self):
# Setup Expected Response
expected_response = {}
expected_response = prediction_service_pb2.BatchPredictResult(
**expected_response
)
operation = operations_pb2.Operation(
name="operations/test_batch_predict", done=True
)
operation.response.Pack(expected_response)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = automl_v1beta1.PredictionServiceClient()
# Setup Request
name = client.model_path("[PROJECT]", "[LOCATION]", "[MODEL]")
input_config = {}
output_config = {}
params = {}
response = client.batch_predict(name, input_config, output_config, params)
result = response.result()
assert expected_response == result
assert len(channel.requests) == 1
expected_request = prediction_service_pb2.BatchPredictRequest(
name=name,
input_config=input_config,
output_config=output_config,
params=params,
)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def predict(project_id,
compute_region,
model_id,
file_path,
score_threshold="0.5"):
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
prediction_client = automl.PredictionServiceClient()
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
'''
# full result
print("Prediction results:")
for result in response.payload:
print("Predicted class name: {}".format(result.display_name))
print("Predicted class score: {}".format(result.classification.score))
'''
# csv result
output = []
for result in response.payload:
output.append((result.classification.score, result.display_name))
output.sort(reverse=True)
print(file_path, end='')
for result in output:
print(",", result[1], end='')
print()
def __init__(self, threadID, name, q, qL):
threading.Thread.__init__(self, group=None)
self.threadID = threadID
self.name = name
self.weight = 0
self.q = q
self.qL = qL
# filter warnings, load the configuration
warnings.filterwarnings("ignore")
self.conf = json.load(open('conf.json'))
# initialize the AutoML API
credentials = service_account.Credentials.from_service_account_file(r"/home/pi/creds.json")
self.prediction_client = automl_v1beta1.PredictionServiceClient(credentials=credentials)
self.modelName = 'projects/{}/locations/us-central1/models/{}'.format(self.conf['project_id'], self.conf['model_id'])
# initialize the camera and grab a reference to the raw camera capture
self.camera = PiCamera()
self.camera.resolution = tuple(self.conf[ "resolution"])
self.camera.framerate = self.conf[ "fps"]
self.rawCapture = PiRGBArray(self.camera, size=tuple(self.conf[ "resolution"]))
# allow the camera to warmup, then initialize the average frame, last
# uploaded timestamp, and frame motion counter
print self.name + "| warming up camera..."
time.sleep(self.conf[ "camera_warmup_time"])
self.avg = None
self.lastUploaded = datetime.datetime.now()
self.motionCounter = 0
# stop event to terminate the thread
self.stopEvent = threading.Event()
# init GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.conf['motion_led_pin'], GPIO.OUT)
def predict(project_id, compute_region, model_id, file_path):
"""Classify the content."""
# [START automl_language_predict]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(
project_id, compute_region, model_id
)
# Read the file content for prediction.
with open(file_path, "rb") as content_file:
snippet = content_file.read()
# Set the payload by giving the content and type of the file.
payload = {"text_snippet": {"content": snippet, "mime_type": "text/plain"}}
# params is additional domain-specific parameters.
# currently there is no additional parameters supported.
params = {}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
if(result.classification.score >6.0)
print("Predicted class name: {}".format(result.display_name))
print("Predicted class score: {}".format(result.classification.score))
def run_automl_single(ocr_path, list_fields, model_id, main_project_id,
compute_region):
"""Runs AutoML NER on a single document and returns the dictionary of results."""
# Set up client for AutoML NER model
automl_client = automl.AutoMlClient()
model_full_id = automl_client.model_path(main_project_id, compute_region,
model_id)
prediction_client = automl.PredictionServiceClient()
# Load text
text = utils.download_string(ocr_path).read().decode('utf-8')
# Call AutoML
payload = {"text_snippet": {"content": text, "mime_type": "text/plain"}}
params = {}
response = prediction_client.predict(model_full_id, payload, params)
# Parse results
results = {'file': os.path.basename(ocr_path).replace('.txt', '.pdf')}
for field in list_fields:
value_field = extract_field_from_payload(text, response.payload, field)
results[field] = value_field
return results
def get_predictions(self,
image_bytes,
model_id='',
score_threshold=u'0.10'):
if model_id == '':
model_id = self.model_id
model_full_id = self.client.model_path(self.project_id,
self.compute_region, model_id)
prediction_client = automl.PredictionServiceClient()
payload = {"image": {"image_bytes": image_bytes}}
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
result = []
predictions = prediction_client.predict(model_full_id, payload, params)
for p in predictions.payload:
result.append((p.display_name, p.classification.score))
return sorted(result, key=lambda _: _[1], reverse=True)
def prediction(data, context):
"""Background Cloud Function to be triggered by Cloud Storage.
This generic function logs relevant data when a file is changed.
Args:
data (dict): The Cloud Functions event payload.
context (google.cloud.functions.Context): Metadata of triggering event.
Returns:
None; the output is written to Stackdriver Logging
"""
print('Event ID: {}'.format(context.event_id))
print('Event type: {}'.format(context.event_type))
print('Bucket: {}'.format(data['bucket']))
print('File: {}'.format(data['name']))
print('Metageneration: {}'.format(data['metageneration']))
print('Created: {}'.format(data['timeCreated']))
print('Updated: {}'.format(data['updated']))
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format('377104581238', 'IOD2191836847552856064')
imagepath = data['bucket'] + "/" + data['name']
storage_client = storage.Client()
bucket = storage_client.get_bucket(data['bucket'])
blob = bucket.blob(data['name'])
content = blob.download_as_string()
payload = {'image': {'image_bytes': content}}
# print(content)
params = {}
response = prediction_client.predict(name, payload, params)
# print(response)
for result in response.payload:
print("Display Name: {}".format(result.display_name))
print("Bounding Box: {}".format(result.image_object_detection.bounding_box))
print("Score: {}".format(result.image_object_detection.score))
def get_prediction(content, project_id, model_id):
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format(project_id, model_id)
payload = {'text_snippet': {'content': content, 'mime_type': 'text/plain' }}
params = {}
request = prediction_client.predict(name, payload, params)
str_request = str(request)
old_list = str_request.split("\n")
bad_chars = ['','{', '}', ' ']
list_request = []
for item in old_list:
#print(item)
item = item.split(" ")
item = [element for element in item if element not in bad_chars]
#list_request.append(item)
#item = ' '.join([token for token in item])
#print(item)
if(item != ""):
for part in item:
list_request.append(part)
pos_ind = list_request.index('"positive"')
neg_ind = list_request.index('"negative"')
if(pos_ind < neg_ind):
ret_str = "positive"
else:
ret_str = "negative"
#score = text.find('score')
# str_request.split("")'''
print("your mood is: "+ret_str)
return request # waits till request is returned
def get_prediction(content, project_id, model_id,number_of_users):
prediction_client = automl_v1beta1.PredictionServiceClient()
name = 'projects/{}/locations/us-central1/models/{}'.format(project_id, model_id)
payload = {'image': {'image_bytes': content }}
# Return the output of activities having confidence score is greater than "0.0"
params = { "score_threshold":"0.0" }
request = prediction_client.predict(name, payload, params)
# Returns a dictionary of all labels that have confidence score greater than 0.0
labels = request.payload
#Array to store confience scores of activities
conf = [0.0, 0.0, 0.0, 0.0]
i = 0
while i<len(labels):
image_label = labels[i].display_name # print this
score_result = labels[i].classification
confidence = score_result.score # print this
conf[i] = confidence
print(image_label)
print(confidence)
i = i+1
os.system('export GOOGLE_APPLICATION_CREDENTIALS="service.json"')
project_id = 'pennapps-252204'
compute_region = 'us-central1'
model_id = 'untitled_1567868172858'
file_path = 'test.png'
score_threshold = u'0.4'
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region, model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
print(model_full_id)
print(params)
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
# -*- coding: UTF-8 -*-
from google.cloud import automl_v1beta1
prediction_client = automl_v1beta1.PredictionServiceClient()
def get_prediction(content):
project_id = '305237550374'
model_id = 'ICN5607979892634288128'
name = 'projects/{}/locations/us-central1/models/{}'.format(
project_id, model_id)
payload = {'image': {'image_bytes': content}}
params = {}
request = prediction_client.predict(name, payload, params)
return request.payload # waits till request is returned
def is_dog(img):
try:
result = get_prediction(img)
if len(result) > 0 and result[0].display_name == 'doudou':
return True
elif len(result) > 2:
pass
except Exception as e:
print 'detect error' + str(e)
return False
key = 'pixelfood-e2b93b66a82f.json'
if __name__ == '__main__':
file_path = sys.argv[1]
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region, model_id)
print(model_full_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient().from_service_account_file(
key)
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
def detect_cartoon(frame):
model = automl_v1beta1.PredictionServiceClient()
path = "projects/" + project_id + "/locations/us-central1/models/" + model_id
result = model.predict(path, {'image': {'image_bytes': frame}})
return result
def predict():
global calorieScores, foodName
# TODO(developer): Uncomment and set the following variables
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
r = request
# # # convert string of image data to uint8
# nparr = np.fromstring(r.data, np.uint8)
# # # decode image
# img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
# print("THE TYPE OF IMAGE IS ")
# print(img)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
# with open(r.data, "rb") as image_file:
# content = image_file.read()
payload = {"image": {"image_bytes": r.data}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
calorieScores = 0
response = prediction_client.predict(model_full_id, payload, params)
for result in response.payload:
foodName = result.display_name
classScore = result.classification.score
if foodName == "caesar_salad":
foodName = "Caesar Salad"
calorieScores = 189
elif foodName == "chicken_wings":
foodName = "Chicken Wings"
calorieScores = 283
elif foodName == "donuts":
foodName = "Donut"
calorieScores = 324
elif foodName == "fried_rice":
foodName = "Ice Cream"
calorieScores = 170
elif foodName == "pizza":
foodName = "Pizza"
calorieScores = 277
elif foodName == "dumplings":
foodName = "Dumplings"
calorieScores = 145
elif foodName == "french_fries":
foodName = "French Fries"
calorieScores = 155
elif foodName == "hamburger":
foodName = "Hamburger"
calorieScores = 186
calories = CALORIES[foodName]
print(calories)
payload = {"foodName": foodName, "calories": calories}
return (json.dumps(payload))