def __init__(self):
self.stub = service_pb2_grpc.V2Stub(ClarifaiChannel.get_grpc_channel())
# moderation cccf390eb32cad478c7ae150069bd2c6
# nsfw - v1.0 ccc76d86d2004ed1a38ba0cf39ecb4b1
# nsfw-v1.0 e9576d86d2004ed1a38ba0cf39ecb4b1
# moderation a3ab820725bb472092a2cd63b1c0035a
# moderation d16f390eb32cad478c7ae150069bd2c6
# self.model_id = 'aaa03c23b3724a16a56b629203edc62c' # General
self.model_id = 'd16f390eb32cad478c7ae150069bd2c6' # moderation
with open(CLARIFAI_KEY, 'r') as f:
self.api_key = f.read()
self.auth = (('authorization', f'Key {self.api_key}'), )
def has_object_on_image(file_name, object_name):
channel = ClarifaiChannel.get_grpc_channel()
app = service_pb2_grpc.V2Stub(channel)
metadata = (('authorization', f'Key {settings.CLARIFAI_API_KEY}'),)
with open(file_name, 'rb') as f:
file_data = f.read()
image = resources_pb2.Image(base64=file_data)
request = service_pb2.PostModelOutputsRequest(
model_id='aaa03c23b3724a16a56b629203edc62c',
inputs=[
resources_pb2.Input(
data=resources_pb2.Data(image=image)
)
])
response = app.PostModelOutputs(request, metadata=metadata)
# print(response)
return check_response_for_object(response, object_name)
def keywords(request):
if request.method != 'POST':
# Method not allowed
return JsonResponse(helpers.create_error_response(405), status=405)
# Check if request has a foodImage file
if 'foodImage' not in request.FILES:
return JsonResponse(helpers.create_error_response(400), status=400)
# Retrieving image from the request
food_image = request.FILES['foodImage'].file.read()
# Client setup
channel = ClarifaiChannel.get_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)
metadata = (('authorization', f"Key {os.environ['CLARIFAI_API_KEY']}"), )
post_model_outputs_response = stub.PostModelOutputs(
service_pb2.PostModelOutputsRequest(
model_id=f"{os.environ['MODEL_ID']}",
inputs=[
resources_pb2.Input(data=resources_pb2.Data(
image=resources_pb2.Image(base64=food_image)))
]),
metadata=metadata)
if post_model_outputs_response.status.code != status_code_pb2.SUCCESS:
# Something went wrong while retrieving info from Clarifai - 502
return JsonResponse(helpers.create_error_response(502), status=502)
# Since only one image was sent, there is only one output
output = post_model_outputs_response.outputs[0]
return JsonResponse(
helpers.create_success_response(output.data.concepts[:5]))
def func_wrapper():
channel = ClarifaiChannel.get_grpc_channel()
func(channel)
channel = ClarifaiChannel.get_json_channel()
func(channel)
def __init__(self, key):
# Construct one of the channels you want to use
self.channel = ClarifaiChannel.get_json_channel()
self.key = key
from flask import Flask, render_template, session, redirect, url_for, flash, request
from werkzeug.utils import secure_filename
import os
from clarifai_grpc.grpc.api import service_pb2, resources_pb2
from clarifai_grpc.grpc.api.status import status_code_pb2
from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
from clarifai_grpc.grpc.api import service_pb2_grpc
stub = service_pb2_grpc.V2Stub(ClarifaiChannel.get_grpc_channel())
metadata = (('authorization', 'Key 24f6926e2f1744aa8e83199cb554d8b0'), )
app = Flask(__name__)
upload_folder = "static/uploads"
allowed_extentions = set(['png', 'jpeg', 'jpg'])
app.config['UPLOAD_FOLDER'] = upload_folder
app.config['SECRET_KEY'] = 'fjhasldkfjhasdflkhasdflkjh'
recyclable_objects = [
"bottle", "cardboard", "glass", "plastic bottle", "plastic container",
"cereal box", "snack box", "phonebook", "magazine", "mail", "paper",
"newspaper", "tin cans", "aluminum can", "steel can", "food container",
"jar", "soft drink bottle", "beer bottle", "wine bottle", "liquor bottle",
"carton", "aersol", "aersol can", "aluminum", "aluminum foil",
"aluminum tray", "stryrofoam", "stryrofoam packaging",
"stryrofoam food container", "stryrofoam drink container", "paper box",
"pizza box", "paper bag", "shredded paper", "plastic bucket",
"plastic tubs", "plastic pot", "plastic tray", "plastic toy",
"plastic food container", "plastic cup", "metal can", "aluminum can",
"wrapping paper", "mail", "newspaper", "book"
import os
from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
from clarifai_grpc.grpc.api import resources_pb2, service_pb2, service_pb2_grpc
from clarifai_grpc.grpc.api.status import status_pb2, status_code_pb2
channel = ClarifaiChannel.get_json_channel()
channel = ClarifaiChannel.get_insecure_grpc_channel()
stub = service_pb2_grpc.V2Stub(channel)
key = os.getenv('API_KEY')
metadata = (('authorization', f'Key {key}'), )
def classification(img):
#with open(img, "rb") as f:
file_bytes = img.read()
post_model_outputs_response = stub.PostModelOutputs(
service_pb2.PostModelOutputsRequest(
model_id="bd367be194cf45149e75f01d59f77ba7",
inputs=[
resources_pb2.Input(data=resources_pb2.Data(
image=resources_pb2.Image(base64=file_bytes)))
]),
metadata=metadata)
if post_model_outputs_response.status.code != status_code_pb2.SUCCESS:
raise Exception("Post model outputs failed, status: " +
post_model_outputs_response.status.description)
from clarifai_grpc.grpc.api import service_pb2_grpc, service_pb2, resources_pb2
from clarifai_grpc.grpc.api.status import status_code_pb2
import os
from google.cloud import vision, translate
from aux_functions import separate_capital_letters
import settings
# Declaração da credencial para APIs do Google e instancia do client
os.environ[
"GOOGLE_APPLICATION_CREDENTIALS"] = "projeto-tcc-276919-afa464aedacb.json"
client = vision.ImageAnnotatorClient()
# Declaração e intancia de client da API da Clarifai
channel = ClarifaiChannel.get_json_channel()
stub = service_pb2_grpc.V2Stub(channel)
#Função que reconhece logos de empresas conhecidas da imagem passada
#---RETORNO: informações sobre a logo, nome e percentual de chance de ser.
def get_logos(content):
# carrega a imagem para a memória
# with io.open(path, 'rb') as image_file:
# content = image_file.read()
image = types.Image(content=content) # define o model da imagem
# Chama a requisição à API e pega sua resposta
response = client.logo_detection(image=image)
logos = response.logo_annotations
def __init__(self, key):
self.channel = ClarifaiChannel.get_grpc_channel()
self.stub = service_pb2_grpc.V2Stub(self.channel)
self.metadata = (('authorization', f'Key {key}'),)
def test_deep_classification_training_with_queries():
stub = service_pb2_grpc.V2Stub(ClarifaiChannel.get_grpc_channel())
app_id = "my-app-" + uuid.uuid4().hex[:20]
post_apps_response = stub.PostApps(
service_pb2.PostAppsRequest(
apps=[
resources_pb2.App(
id=app_id,
default_workflow_id="General",
)
]
),
metadata=pat_key_metadata(),
)
raise_on_failure(post_apps_response)
post_keys_response = stub.PostKeys(
service_pb2.PostKeysRequest(
keys=[
resources_pb2.Key(
description="All scopes",
scopes=["All"],
apps=[resources_pb2.App(id=app_id, user_id="me")],
)
],
),
metadata=pat_key_metadata(),
)
raise_on_failure(post_keys_response)
api_key = post_keys_response.keys[0].id
template_name = "classification_cifar10_v1"
model_id = "my-deep-classification-" + uuid.uuid4().hex
model_type = _get_model_type_for_template(stub, api_key, template_name)
train_info_params = struct_pb2.Struct()
train_info_params.update(
{
"template": template_name,
"num_epochs": 2,
"num_gpus": 0,
}
)
post_models_response = stub.PostModels(
service_pb2.PostModelsRequest(
models=[
resources_pb2.Model(
id=model_id,
model_type_id=model_type.id,
train_info=resources_pb2.TrainInfo(params=train_info_params),
output_info=resources_pb2.OutputInfo(
data=resources_pb2.Data(
concepts=[
resources_pb2.Concept(id="train-concept"),
resources_pb2.Concept(id="test-only-concept"),
]
),
),
)
]
),
metadata=api_key_metadata(api_key),
)
raise_on_failure(post_models_response)
train_and_test = ["train", "test"]
inputs = []
annotations = []
for i, url in enumerate(URLS):
input_id = str(i)
inputs.append(
resources_pb2.Input(
id=input_id, data=resources_pb2.Data(image=resources_pb2.Image(url=url))
)
)
train_annotation_info = struct_pb2.Struct()
train_annotation_info.update({"split": train_and_test[i % 2]})
ann = resources_pb2.Annotation(
input_id=input_id,
annotation_info=train_annotation_info,
data=resources_pb2.Data(concepts=[resources_pb2.Concept(id="train-concept", value=1)]),
)
# Add an extra concept to the test set which show should up in evals, but have a bad score since there is
# no instance of it in the train set.
if i % 2 == 1:
ann.data.concepts.append(resources_pb2.Concept(id="test-only-concept", value=1))
annotations.append(ann)
post_inputs_response = stub.PostInputs(
service_pb2.PostInputsRequest(inputs=inputs),
metadata=api_key_metadata(api_key),
)
raise_on_failure(post_inputs_response)
wait_for_inputs_upload(stub, api_key_metadata(api_key), [str(i) for i in range(len(URLS))])
post_annotations_response = stub.PostAnnotations(
service_pb2.PostAnnotationsRequest(annotations=annotations),
metadata=api_key_metadata(api_key),
)
raise_on_failure(post_annotations_response)
train_annotation_info = struct_pb2.Struct()
train_annotation_info.update({"split": "train"})
train_query = resources_pb2.Query(
ands=[
resources_pb2.And(
annotation=resources_pb2.Annotation(annotation_info=train_annotation_info)
),
]
)
test_annotation_info = struct_pb2.Struct()
test_annotation_info.update({"split": "train"})
test_query = resources_pb2.Query(
ands=[
resources_pb2.And(
negate=True,
annotation=resources_pb2.Annotation(annotation_info=test_annotation_info),
),
]
)
post_model_versions_response = stub.PostModelVersions(
service_pb2.PostModelVersionsRequest(
model_id=model_id,
train_search=resources_pb2.Search(query=train_query),
test_search=resources_pb2.Search(query=test_query),
),
metadata=api_key_metadata(api_key),
)
raise_on_failure(post_model_versions_response)
model_version_id = post_model_versions_response.model.model_version.id
wait_for_model_trained(stub, api_key_metadata(api_key), model_id, model_version_id)
post_model_outputs_response = stub.PostModelOutputs(
service_pb2.PostModelOutputsRequest(
model_id=model_id,
version_id=model_version_id,
inputs=[
resources_pb2.Input(
data=resources_pb2.Data(image=resources_pb2.Image(url=URLS[0]))
)
],
),
metadata=api_key_metadata(api_key),
)
raise_on_failure(post_model_outputs_response)
concepts = post_model_outputs_response.outputs[0].data.concepts
assert len(concepts) == 2
assert concepts[0].id == "train-concept"
assert concepts[1].id == "test-only-concept"
assert concepts[1].value <= 0.0001
delete_app_response = stub.DeleteApp(
service_pb2.DeleteAppRequest(
user_app_id=resources_pb2.UserAppIDSet(user_id="me", app_id=app_id)
),
metadata=pat_key_metadata(),
)
raise_on_failure(delete_app_response)
def __init__(self, app_id):
self.app_id = app_id
self.channel = ClarifaiChannel.get_json_channel()
self.stub = service_pb2_grpc.V2Stub(self.channel)
