def main():
logger = logging.getLogger('clarifai')
logger.handlers = []
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.INFO)
app = ClarifaiApp()
delete_all_inputs(app, logger)
app.models.delete_all()
app.wait_until_inputs_delete_finish()
app.wait_until_models_delete_finish()
app.inputs.create_image_from_url(
urls[0], concepts=['train', 'railway'], allow_duplicate_url=True)
app.inputs.create_image_from_url(urls[3], concepts=['dog', 'animal'], allow_duplicate_url=True)
model_id = uuid.uuid4().hex
model1 = app.models.create(model_id=model_id, concepts=['train', 'railway', 'dog', 'animal'])
model = model1.train(timeout=240)
if model.model_status_code != 21100:
logger.error('Model not trained in 240 seconds with 2 inputs. Test could not continue.')
exit(2)
python clarifai_run_on_folder.py --input_image_folder images/negative --class_type negative
python clarifai_run_on_folder.py --input_image_folder images/nudity --class_type nudity
python clarifai_run_on_folder.py --input_image_folder images/violence --class_type violence
"""
parser = argparse.ArgumentParser()
parser.add_argument("--input_image_folder", default="", help="")
parser.add_argument("--class_type", default="", help="")
args = parser.parse_args()
print(args)
with open('api_keys.json') as f:
api_keys = json.load(f)
app = ClarifaiApp(api_key=api_keys['CLARIFAI_API_KEY'])
# get the general model
model = app.models.get("general-v1.3")
all_violence_files = glob.glob('{}/*'.format(args.input_image_folder))
print(all_violence_files)
#result = predict_with_local_file('images/Man-holding-a-knife-via-Shutterstock.jpg')
for fp in all_violence_files:
file_name = fp.split('\\')[1]
output_json_path = 'results/{}_image_results/{}.json'.format(args.class_type, file_name)
if os.path.exists(output_json_path):
print('Path exists: {}'.format(output_json_path))
continue
from clarifai import rest
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
import json
import requests
app = ClarifaiApp(api_key='ec6402c259dc42a5a0d8d48b1e121cad')
model = app.models.get('nsfw-v1.0')
image = ClImage(url='https://pbs.twimg.com/media/BFG-BCSCMAA7sF9.jpg')
response = model.predict([image])
concepts = response['outputs'][0]['data']['concepts']
for concept in concepts:
if concept["name"] == "sfw":
sfw_val = concept["value"]
if concept["name"] == "nsfw":
nsfw_val = concept["value"]
#print(concept['name'], concept['value'])
print("sfw: ", sfw_val)
print("nsfw: ", nsfw_val)
data = {
"type":
"bulk",
"args": [{
"type": "delete",
"args": {
"table": "clarifai_nsfw",
"where": {}
}
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
from clarifai.client import ClarifaiApi
import os
import json
import argparse
from key import *
app = ClarifaiApp(CLIENT_KEY, CLIENT_SECRET)
clarifai_api = ClarifaiApi(CLIENT_KEY, CLIENT_SECRET)
# get the general model
model = app.models.get("general-v1.3")
def classify_images(folder):
images = []
image_prefix = folder + "/{0}"
for frame in os.listdir(folder):
if ".jpg" in frame:
img = ClImage(file_obj=open(image_prefix.format(frame), 'rb'))
images.append(img)
response = model.predict(images)
return extract_result(response)
def extract_result(response):
data = response["outputs"][0]["data"]["concepts"]
result = list()
# a list of tuples in the form (name, probability)
for datum in data:
from flask import Flask, render_template, request
from werkzeug import secure_filename
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
app = ClarifaiApp(api_key='ed78ccc5e8764fee8fc8c750ef421de2')
appF = Flask(__name__)
@appF.route('/upload')
def upload_file2():
return render_template('upload.html')
@appF.route('/uploader', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['file']
f.save(secure_filename(f.filename))
#return determine(f.filename)
return render_template('afterUpload.html',
answer=determine(f.filename))
#return 'file uploaded successfully'
def determine(image):
# get the general model
#model = app.models.get("general-v1.3")
model = app.models.get("Ocean Cleanup")
image = ClImage(file_obj=open(image, 'rb'))
def setUpClass(cls):
cls.api = ApiClient(log_level=logging.WARN)
cls.app = ClarifaiApp(log_level=logging.WARN)
#nltk.download('twitter_samples')
nltk.download('brown')
from nltk.corpus import brown
for category in brown.categories():
words = brown.words(categories=category)
text = " ".join(words)
filename = 'data-markovify/' + category + '.txt'
outfile = open(filename, 'w')
outfile.write(text)
outfile.close()
import inflect
import markovify
app = ClarifaiApp(api_key='1f2c93de75074a088597cd7791491b5a')
model = app.public_models.general_model
'''
Lazytag Bot
1. Generate list of keywords from Clarifai model
2. Filter the keywords
3. Recieve most search words from each sub-reddit from the worddit api
4. Compare the keywords with most search word
5. Find the subreddit that has the highest probability of producing an acurate comment
6. Generate comment with comments produced from the subreddit
'''
## Inputs ##
# an image url
sample_img = "https://images.unsplash.com/photo-1518791841217-8f162f1e1131?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=2850&q=80"
if len(sys.argv) > 1:
from clarifai.rest import ClarifaiApp
from food import search_food
import json
import urllib2
url = 'https://api.nal.usda.gov/ndb/search/?format=json&api_key=fsH5vnlqW2BI46MwQCEvrmw2nAJjb0QyOjWbIoaS&q=beer, coke, soda&ds=Standard Reference'
app = ClarifaiApp(api_key='4ca3a32fd0fc40eeb9bb314978689e3a')
def get_relevant_tags(image_url):
response_data = app.tag_urls(urls=[image_url],
model_id='bd367be194cf45149e75f01d59f77ba7')
tag_urls = []
for concept in response_data['outputs'][0]['data']['concepts']:
tag_urls.append(concept['name'])
str = "Hello from RowdyHacks\n"
#return str + ' \n'.join(tag_urls[0:3])
return tag_urls[0:3]
#print get_relevant_tags('https://brendid.com/wp-content/uploads/2015/10/Pear-Recipes-7.jpg')
#print get_food_nut()
def test_add_concepts(mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(
mock_http_client, """
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": [{
"id": "@inputID",
"data": {
"image": {
"url": "@imageURL"
},
"concepts": [
{
"id": "@positiveConcept1",
"value": 1
},
{
"id": "@positiveConcept2",
"value": 1
},
{
"id": "@negativeConcept1",
"name": "@negativeConceptName1",
"value": 0
},
{
"id": "@negativeConcept2",
"value": 0
}
]
},
"created_at": "2017-10-13T20:53:00.253139Z",
"modified_at": "2017-10-13T20:53:00.868659782Z",
"status": {
"code": 30200,
"description": "Input image modification success"
}
}]
}
""")
app = ClarifaiApp()
image = app.inputs.add_concepts('@inputID', ['@positiveConcept1'],
['@negativeConcept1'])
assert image.input_id == '@inputID'
assert image.url == '@imageURL'
assert_request(
mock_execute_request, 'PATCH', '/v2/inputs', """
{
"inputs": [
{
"id": "@inputID",
"data": {
"concepts": [
{
"id": "@positiveConcept1",
"value": 1
},
{
"id": "@negativeConcept1",
"value": 0
}
]
}
}
],
"action":"merge"
}
""")
def test_get_all(mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(mock_http_client,
json_responses=[
"""
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": [
{
"id": "@inputID1",
"data": {
"image": {
"url": "https://some.image.url1"
},
"geo": {
"geo_point": {
"longitude": 55,
"latitude": 66
}
}
},
"created_at": "2019-01-17T14:02:21.216473Z",
"modified_at": "2019-01-17T14:02:21.800792Z",
"status": {
"code": 30000,
"description": "Download complete"
}
},
{
"id": "@inputID2",
"data": {
"image": {
"url": "https://some.image.url2"
}
},
"created_at": "2019-01-17T14:02:21.216473Z",
"modified_at": "2019-01-17T14:02:21.800792Z",
"status": {
"code": 30000,
"description": "Download complete"
}
}
]
}
""", """
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": []
}
"""
])
app = ClarifaiApp()
images = list(app.inputs.get_all())
assert images[0].input_id == '@inputID1'
assert images[0].url == 'https://some.image.url1'
assert images[0].geo.geo_point.longitude == 55
assert images[0].geo.geo_point.latitude == 66
assert images[1].input_id == '@inputID2'
assert images[1].url == 'https://some.image.url2'
assert_requests(mock_execute_request,
requests=[('GET', '/v2/inputs', """
{"page": 1, "per_page": 20}
"""), ('GET', '/v2/inputs', """
{"page": 2, "per_page": 20}
""")])
def test_bulk_update_with_metadata(
mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(
mock_http_client, """
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": [{
"id": "@inputID",
"data": {
"image": {
"url": "@imageURL"
},
"concepts": [{
"id": "concept1",
"name": "concept1",
"value": 1,
"app_id": "@appID"
}],
"metadata": {
"@key1": "@value1",
"@key2": "@value2"
}
},
"created_at": "2017-11-02T15:08:22.005157Z",
"modified_at": "2017-11-02T15:08:23.071624222Z",
"status": {
"code": 30200,
"description": "Input image modification success"
}
}]
}
""")
app = ClarifaiApp()
images = app.inputs.bulk_update([
Image(image_id='@inputID',
metadata={
'@key1': '@value1',
'@key2': '@value2',
})
],
action='overwrite')
assert images[0].input_id == '@inputID'
assert images[0].url == '@imageURL'
assert images[0].status.code == 30200
assert images[0].metadata == {'@key1': '@value1', '@key2': '@value2'}
assert_request(
mock_execute_request, 'PATCH', '/v2/inputs', """
{
"inputs": [
{
"id": "@inputID",
"data": {
"metadata": {
"@key1": "@value1",
"@key2": "@value2"
}
}
}
],
"action":"overwrite"
}
""")
def test_bulk_update_with_regions(
mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(
mock_http_client, """
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": [
{
"id": "@inputID",
"data": {
"image": {
"url": "@imageURL"
},
"concepts": [
{
"id": "@concept1",
"name": "@concept1",
"value": 1,
"app_id": "@appID"
},
{
"id": "@concept2",
"name": "@concept2",
"value": 0,
"app_id": "@appID"
}
]
},
"created_at": "2019-01-29T15:23:21.188492Z",
"modified_at": "2019-01-29T15:23:21.575667Z",
"status": {
"code": 30200,
"description": "Input image modification success"
}
}
]
}
""")
app = ClarifaiApp()
images = app.inputs.bulk_update([
Image(image_id='@inputID',
regions=[
Region(region_info=RegionInfo(
bbox=BoundingBox(0.5, 0.5, 1.0, 1.0),
feedback_type=FeedbackType.misplaced),
concepts=[
Concept(concept_id='@concept1', value=True),
Concept(concept_id='@concept2', value=False)
],
region_id='@regionID',
face=Face(identity=FaceIdentity(concepts=[
Concept(concept_id='@faceConcept1', value=True),
Concept(concept_id='@faceConcept2', value=False),
])))
])
],
action='overwrite')
assert images[0].input_id == '@inputID'
assert images[0].url == '@imageURL'
assert images[0].status.code == 30200
assert_request(
mock_execute_request, 'PATCH', '/v2/inputs', """
{
"inputs": [
{
"id": "@inputID",
"data": {
"regions": [
{
"id": "@regionID",
"region_info": {
"bounding_box": {
"top_row": 0.5,
"left_col": 0.5,
"bottom_row": 1,
"right_col": 1
},
"feedback": "misplaced"
},
"data": {
"concepts": [
{
"id": "@concept1",
"value": 1
},
{
"id": "@concept2",
"value": 0
}
],
"face": {
"identity": {
"concepts": [
{
"id": "@faceConcept1",
"value": 1
},
{
"id": "@faceConcept2",
"value": 0
}
]
}
}
}
}
]
}
}
],
"action": "overwrite"
}
""")
def test_bulk_create_image(mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(
mock_http_client, """
{
"status": {
"code": 10000,
"description": "Ok"
},
"inputs": [
{
"id": "@inputID1",
"data": {
"image": {
"url": "https://some.image.url1"
},
"geo": {
"geo_point": {
"longitude": 55,
"latitude": 66
}
}
},
"created_at": "2019-01-17T12:43:04.895006174Z",
"modified_at": "2019-01-17T12:43:04.895006174Z",
"status": {
"code": 30001,
"description": "Download pending"
}
},
{
"id": "@inputID2",
"data": {
"image": {
"url": "https://some.image.url2"
}
},
"created_at": "2019-01-17T12:43:04.895006174Z",
"modified_at": "2019-01-17T12:43:04.895006174Z",
"status": {
"code": 30001,
"description": "Download pending"
}
}
]
}
""")
app = ClarifaiApp()
images = app.inputs.bulk_create_images([
Image(url='https://some.image.url1',
image_id='@inputID1',
allow_dup_url=True,
geo=Geo(geo_point=GeoPoint(55, 66))),
Image(url='https://some.image.url2',
image_id='@inputID2',
allow_dup_url=True),
])
assert images[0].input_id == '@inputID1'
assert images[0].url == 'https://some.image.url1'
assert images[0].geo.geo_point.longitude == 55
assert images[0].geo.geo_point.latitude == 66
assert images[0].status.code == 30001
assert images[1].input_id == '@inputID2'
assert images[1].url == 'https://some.image.url2'
assert not images[1].geo
assert images[1].status.code == 30001
assert_request(
mock_execute_request, 'POST', '/v2/inputs', """
{
"inputs": [
{
"id": "@inputID1",
"data": {
"image": {
"url": "https://some.image.url1",
"allow_duplicate_url": true
},
"geo": {
"geo_point": {
"longitude": 55,
"latitude": 66
}
}
}
},
{
"id": "@inputID2",
"data": {
"image": {
"url": "https://some.image.url2",
"allow_duplicate_url": true
}
}
}
]
}
""")
from clarifai.rest import ClarifaiApp
from pprint import pprint
client_id = "TMWN2VTpC-gVCqsQM8etnUXRoEYJwFdeK7R0L589"
client_secret = "XgqM1Hle2TY7NEZ0PPKS3op02X2RkCrbfegbr3vS"
StyAiconcepts = ['arty','business','casual','chic','elegant','female','goth','preppy','streetwear']
app = ClarifaiApp(client_id, client_secret)
query = app.inputs.search_by_predicted_concepts(concepts=['men','streetwear'])
print len(query)
for q in query:
model = app.models.get("general-v1.3")
# pprint(model.predict([q]))
# raw_input()
def test_search_concepts_with_language(
mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(mock_http_client,
json_responses=[
"""
{
"status": {
"code": 10000,
"description": "Ok"
},
"concepts": [
{
"id": "@conceptID1",
"name": "狗",
"value": 1,
"created_at": "2016-03-17T11:43:01.223962Z",
"language": "zh",
"app_id": "main"
},
{
"id": "@conceptID2",
"name": "狗仔队",
"value": 1,
"created_at": "2016-03-17T11:43:01.223962Z",
"language": "zh",
"app_id": "main"
}
]
}
""", """
{
"status": {
"code": 10000,
"description": "Ok"
},
"concepts": []
}
"""
])
app = ClarifaiApp()
concepts = list(app.concepts.search('狗*', lang='zh'))
assert concepts[0].concept_id == '@conceptID1'
assert concepts[0].concept_name == u'狗'
assert concepts[1].concept_id == '@conceptID2'
assert concepts[1].concept_name == u'狗仔队'
assert_requests(mock_execute_request,
requests=[('POST', '/v2/concepts/searches', """
{
"concept_query": {
"name": "狗*",
"language": "zh"
},
"pagination": {
"per_page": 20,
"page": 1
}
}
"""),
('POST', '/v2/concepts/searches', """
{
"concept_query": {
"name": "狗*",
"language": "zh"
},
"pagination": {
"per_page": 20,
"page": 2
}
}
""")])
def main():
app = ClarifaiApp()
model = app.models.get('general-v1.3')
bytes = raw_input("base64: ")
print model.predict_by_base64(bytes)['outputs'][0]['data']['concepts']
def __init__(self, api_key, api_id):
self.api_key = api_key
self.api_id = api_id
self.app = ClarifaiApp(api_key=self.api_key)
self.client = wolframalpha.Client(self.api_id)
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
import os
APP = ClarifaiApp(api_key="a11ec80513f94400a2caf2867db4bca6")
# APP.inputs.delete_all()
# app.inputs.delete_all()
def sendData(letter):
FOLDER_PATH = "/Users/singhdas/Downloads/asl-alphabet/asl_alphabet_train/" + letter.upper(
) + "/"
alphabets = "abc"
count = 0
lst = []
#
for filename in os.listdir(FOLDER_PATH):
if (filename >= "C1550.jpg" and count < 128):
count += 1
not_concepts = list(alphabets.replace(letter.lower(), ""))
lst.append(
ClImage(filename=FOLDER_PATH + filename,
concepts=[letter.lower()],
not_concepts=not_concepts))
# break
# print(lst)
APP.inputs.bulk_create_images(lst)
print("Done")
def __init__(self, toml_file=None):
super().__init__(toml_file)
self.app = ClarifaiApp(api_key=Bundle.API_KEY)
self.set_bundle(Bundle)
self.set_ready()
from django.shortcuts import render, redirect
from .models import Clothing
from .forms import ClothingForm
from clarifai import rest
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
#Jason's Clarifai Client ID, Client Secret
app = ClarifaiApp("wPXX8nSrRj_A25bqQAdAurGdZdbxzhJWELL9aaQ2",
"SRRlIyrXfV7bJkNE7R3naCBPkxw3J-UwqVgcxJhJ")
#Model for Apparel Prediction
model = app.models.get('e0be3b9d6a454f0493ac3a30784001ff')
#Takes a URL in text, returns the response as a string
#This function is the main part of this code, use it to format any clarifai API response
def clarify(urlstr):
x = app.inputs.create_image_from_filename(urlstr)
predictions = str(model.predict([x]))
#Outputing the response string to a file and formatting it
fil = open('output.txt', 'w')
for i in predictions:
if i == '}':
fil.write('}\n')
else:
fil.write(i)
#Takes the highest confidence line
fil = open('output.txt', 'r')
for line in fil:
def setUpClass(cls):
cls.app = ClarifaiApp(log_level=logging.WARN)
# -*- coding: utf-8 -*-
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
import pandas as pd
import csv
app = ClarifaiApp(api_key='211d6ec030764627b5b07984b4881cda')
#paintings = pd.read_csv('../dados/paintings.csv') #read data and name columns
paintings = pd.read_csv('../dados/treino.csv', sep=';', encoding='latin-1')
all_concepts = []
todos_autores = []
todas_escolas = []
todas_tecnicas = []
i = 0
for index, row in paintings.iterrows():
if i < 1000:
tecnica = row['TECHNIQUE'].split(',')[0]
autor = row['AUTHOR']
escola = row['SCHOOL']
all_concepts = all_concepts + [tecnica, autor, escola]
todos_autores.append(autor)
todas_escolas.append(escola)
todas_tecnicas.append(tecnica)
i = i + 1
all_concepts = list(set(all_concepts))
todas_escolas = list(set(todas_escolas))
todos_autores = list(set(todos_autores))
from clarifai.rest import ClarifaiApp
app = ClarifaiApp("ixACIQvGqKKcJCGLT_xnEh4_jlG7dRKXuzF4jam3",
"-XQ5gLtB0ZljTUEmoaqV4LI8UXdlwZNEvLTkSXt-")
model = app.models.get('general-v1.3')
response = model.predict_by_url(
url='https://avatars1.githubusercontent.com/u/3252741?v=3&s=400')
for tag in response["outputs"][0]["data"]["concepts"]:
print(tag["name"])
os.system("sudo google_speech 'capture complete. uploading file '")
destination_blob_name = name
source_file_name = name
blob = bucket.blob(destination_blob_name)
blob.upload_from_filename(source_file_name)
blob.make_public()
print('File {} uploaded to {}.'.format(source_file_name,
destination_blob_name))
imageurl = 'https://storage.googleapis.com/melanomadetector/candidate.jpg'
app = ClarifaiApp(api_key=api_key)
model = app.models.get('melanomadetector')
model.model_version = 'd472e3e2fab84c698de67c47dfeb1123'
image = ClImage(url=imageurl)
os.system("sudo google_speech 'upload complete. analyzing '")
output = model.predict([image])
print(output)
print('----------')
##jsonres = json.loads(output)
import random
def scrambled(orig): ##shuffling a list of image locations
dest = orig[:]
random.shuffle(dest)
return dest
def batch(iterable, n=128):
l = len(iterable)
for ndx in range(0, l, n):
yield iterable[ndx:min(ndx + n, l)]
app = ClarifaiApp(api_key='REDACTED')
img_locs = scrambled(
glob(".//persons_cropped//*.jpg")) #all photos in the 'no' set, shuffled
no_train = img_locs[:401] #select the training data for 'no'
yes_train = glob(".//yes//*.jpg")[:401] #same for 'yes'
no_val = img_locs[401:]
yes_val = img_locs[401:]
yes_img_list = [
ClImage(filename=image, concepts=["yes"]) for image in yes_train
] #creating lists of Clarifai data points and labels
no_img_list = [ClImage(filename=image, concepts=["no"]) for image in no_train]
test_nos = [ClImage(filename=image) for image in no_val]
import imutils
import cv2
from googletrans import Translator
app = Flask(__name__)
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
UPLOAD_FOLDER = os.path.join(APP_ROOT, 'images/')
ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
sess = Session()
application = ClarifaiApp(api_key='eb7f93f1cce54defb92e276ab515d948')
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
def get_ext(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower()
app.add_url_rule('/images/<filename>', 'uploaded_file', build_only=True)
app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
'/images': app.config['UPLOAD_FOLDER']
})
@app.route('/images/predict', methods=['GET','POST'])
parser.add_argument("--num_iter",
type=int,
default=5,
help="number of iterations to run")
parser.add_argument("--group_size",
type=int,
default=10000,
help="Number of features to group together")
parser.add_argument("--delta",
type=float,
default=1.0,
help="local perturbation")
args = parser.parse_args()
app = ClarifaiApp()
model = app.models.get(args.target_model)
time1 = time.time()
success = 0
avg_l2_perturb = 0
curr_image = args.target_image_name + '.jpg'
curr_sample = np.array(mpimg.imread(curr_image), dtype=float)
array_shape = curr_sample.shape
if len(curr_sample.shape) > 2:
curr_sample = curr_sample[:, :, :3]
else:
curr_sample = curr_sample.reshape((array_shape[0], array_shape[1], 1))
BATCH_SIZE = 1
def __init__(self, api_key: str = None, logger=None):
self.app = ClarifaiApp(api_key=api_key)
self.model = self.app.public_models.general_model
self.logger = logger
import requests
import csv
import os
import json
import argparse
import requests
import random
import re
from clarifai.rest import ClarifaiApp
from clarifai.rest import Image as ClImage
app = ClarifaiApp(api_key='')
model = app.models.get('demographics')
collected = 0
#------------------------------
count1 = 0
count2 = 0
for jsonfile in os.listdir('real'):
print(count1, " files collected")
print(count2, " files skipped")
if os.path.exists("real_demographic_response" + os.sep + jsonfile):
count1 += 1
print("Already got data for ", jsonfile)
continue
print("Working on real user: ", jsonfile)
try:
current = json.load(open('real' + os.sep + jsonfile, 'r'))
img_list = current['images']
img_paths = []
def test_get_all_models(mock_http_client): # type: (mock.Mock) -> None
mock_execute_request = mock_request(mock_http_client,
json_responses=[
"""
{
"status": {
"code": 10000,
"description": "Ok"
},
"models": [
{
"id": "@modelID1",
"name": "@modelName1",
"created_at": "2019-01-16T23:33:46.605294Z",
"app_id": "main",
"output_info": {
"message": "Show output_info with: GET /models/{model_id}/output_info",
"type": "facedetect",
"type_ext": "facedetect"
},
"model_version": {
"id": "28b2ff6148684aa2b18a34cd004b4fac",
"created_at": "2019-01-16T23:33:46.605294Z",
"status": {
"code": 21100,
"description": "Model trained successfully"
},
"train_stats": {}
},
"display_name": "Face Detection"
},
{
"id": "@modelID2",
"name": "@modelName2",
"created_at": "2019-01-16T23:33:46.605294Z",
"app_id": "main",
"output_info": {
"message": "Show output_info with: GET /models/{model_id}/output_info",
"type": "embed",
"type_ext": "detect-embed"
},
"model_version": {
"id": "fc6999e5eb274dfdba826f6b1c7ffdab",
"created_at": "2019-01-16T23:33:46.605294Z",
"status": {
"code": 21100,
"description": "Model trained successfully"
},
"train_stats": {}
},
"display_name": "Face Embedding"
}
]
}
""", """
{
"status": {
"code": 10000,
"description": "Ok"
},
"models": []
}
"""
])
app = ClarifaiApp()
models = list(app.models.get_all())
assert models[0].model_id == '@modelID1'
assert models[0].model_name == '@modelName1'
assert models[0].output_info['type_ext'] == 'facedetect'
assert models[1].model_id == '@modelID2'
assert models[1].model_name == '@modelName2'
assert models[1].output_info['type_ext'] == 'detect-embed'
assert_requests(mock_execute_request, [
('GET', '/v2/models', '{"per_page": 20, "page": 1}'),
('GET', '/v2/models', '{"per_page": 20, "page": 2}'),
])
from clarifai.rest import ClarifaiApp
myApi = '937179c1c41f4378b15017c3bc501ce4'
app = ClarifaiApp(api_key=myApi)
def predict(imageLink, myApi):
app = ClarifaiApp(api_key=myApi)
model = app.public_models.general_model
response = model.predict_by_filename(imageLink)
concepts = response['outputs'][0]['data']['concepts']
results = []
for concept in concepts:
results.append((concept['name']))
return results
