def classifier(img, url):
image_loader = 'yahoo'
input_file = img
input_type = 'tensor'
model_weights = 'data/open_nsfw-weights.npy'
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[input_type.upper()]
model.build(weights_path=model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
# fn_load_image = img
sess.run(tf.global_variables_initializer())
image = fn_load_image(input_file)
predictions = sess.run(model.predictions,
feed_dict={model.input: image})
sess.close()
return {
'url': url,
'sfw': str(predictions[0][0]),
'nsfw': str(predictions[0][1])
}
def main(argv):
global sess
global model
parser = argparse.ArgumentParser()
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-t",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
args = parser.parse_args()
model = OpenNsfwModel()
sess = tf.Session()
if not (sess):
exit(1)
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
sess.run(tf.global_variables_initializer())
print("Session initialized. Running flask")
app.run(debug=True, host='0.0.0.0')
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-i",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
args = parser.parse_args()
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(
tf.Session(graph=tf.get_default_graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(args.input_file)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(args.input_file))
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file", help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m", "--model_weights", required=True,
help="Path to trained model weights file")
parser.add_argument("-l", "--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-i", "--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()])
args = parser.parse_args()
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(args.input_file)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(args.input_file))
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
def predict_nsfw_faster(image_path):
print("predicting nsfw for the image: ", image_path)
model = OpenNsfwModel()
with tf.Session() as sess:
itype = InputType.TENSOR.name.lower()
image_loader = IMAGE_LOADER_TENSORFLOW
input_type = InputType[itype.upper()]
model.build(weights_path="open_nsfw-weights.npy", input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(image_path)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
sfw_score = predictions[0][0]
print("\tSFW score:\t{}".format(predictions[0][0]))
print("\tNSFW score:\t{}".format(predictions[0][1]))
if sfw_score > 0.94:
return "sfw"
else:
return "nsfw"
def get(self):
model = OpenNsfwModel()
fname = request.args.get('fn')
with tf.Session() as sess:
model.build(weights_path=model_weights, input_type=input_type)
import base64
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(fname)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
sfw, nsw = "{}:{}".format(*predictions[0]).split(":")
scores = {
"fileName" : fname,
"sfw" : sfw,
"nsw" : nsw
}
return jsonify(scores)
class nsfw:
def __init__(self):
"""Cart bar detection class
Arguments
---------
frozen_path: str
Path to .pb model. Default="carts_model/frozen_inference_graph.pb"
gpu_memory_fraction: float
Percentage of how much gpu should the model use. If too little model can fail to load. Default=0.5
gpu_device: str
Required to set env variable CUDA_VISIBLE_DEVICES so Tensorflow only uses desired gpu. Default='0'
"""
"""Limit visible GPUs"""
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
self.model = OpenNsfwModel()
self.model.build()
self.sess = tf.Session()
self.sess.run(tf.initialize_all_variables())
def classify(self, image_str):
img = decode_img_base64(image_str)
cv2.imwrite("img.jpg", img)
fn_load_image = create_tensorflow_image_loader(self.sess)
image = fn_load_image("img.jpg")
predictions = self.sess.run(self.model.predictions,feed_dict={self.model.input: image})
# print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
return predictions[0]
def __init__(self,
model_weights = '/home/citao/github/tensorflow-open_nsfw/data/open_nsfw-weights.npy',
image_loader = 'IMAGE_LOADER_YAHOO',
input_type = InputType.TENSOR.name.lower()
):
self._sess = tf.Session()
self._model = OpenNsfwModel()
input_type = InputType[input_type.upper()]
self._model.build(weights_path = model_weights,
input_type = input_type)
self.fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader == IMAGE_LOADER_TENSORFLOW:
self.fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
else:
self.fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
self.fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
self._sess.run(tf.global_variables_initializer())
def __init__(self):
"""Cart bar detection class
Arguments
---------
frozen_path: str
Path to .pb model. Default="carts_model/frozen_inference_graph.pb"
gpu_memory_fraction: float
Percentage of how much gpu should the model use. If too little model can fail to load. Default=0.5
gpu_device: str
Required to set env variable CUDA_VISIBLE_DEVICES so Tensorflow only uses desired gpu. Default='0'
"""
"""Limit visible GPUs"""
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
self.model = OpenNsfwModel()
self.model.build()
self.sess = tf.Session()
self.sess.run(tf.initialize_all_variables())
def nsfw_main():
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
IMAGE_LOADER_TENSORFLOW = "tensorflow"
class args:
pass
args.input_file = "girl.jpg"
args.model_weights = "data/open_nsfw-weights.npy"
args.image_loader = IMAGE_LOADER_TENSORFLOW
args.input_type = InputType.TENSOR.name.lower()
model = OpenNsfwModel()
# This is important for reset graph
tf.reset_default_graph()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(args.input_file)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(args.input_file))
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
def main(argv):
global sess
global model
parser = argparse.ArgumentParser()
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-t",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
parser.add_argument("-p", "--port", default=6000, help="port number")
args = parser.parse_args()
model = OpenNsfwModel()
gpuConfig = tf.ConfigProto(
gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.3),
device_count={'GPU': 1})
sess = tf.Session(config=gpuConfig)
if not (sess):
exit(1)
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
sess.run(tf.global_variables_initializer())
print("Session initialized. Running flask")
port = detect_port(int(args.port))
app.run(debug=False, host='0.0.0.0', port=port)
class nsfw_detector():
def __init__(self,
model_weights = '/home/citao/github/tensorflow-open_nsfw/data/open_nsfw-weights.npy',
image_loader = 'IMAGE_LOADER_YAHOO',
input_type = InputType.TENSOR.name.lower()
):
self._sess = tf.Session()
self._model = OpenNsfwModel()
input_type = InputType[input_type.upper()]
self._model.build(weights_path = model_weights,
input_type = input_type)
self.fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader == IMAGE_LOADER_TENSORFLOW:
self.fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
else:
self.fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
self.fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
self._sess.run(tf.global_variables_initializer())
def predict(self, input_file):
image = self.fn_load_image(input_file)
predictions = self._sess.run(
self._model.predictions,
feed_dict = {self._model.input: image}
)
probs = predictions[0]
result = {
'SFW': probs[0],
'NSFW': probs[1]
}
return result
def run():
global BATCH_SIZE
global testImg
global LR
global logs_train_dir
prepare()
images = []
labels = []
for line in testImg:
images.append(line)
filename = os.path.splitext(os.path.split(line)[1])[0]
true_index = 0
if filename.split('P**n')[0] == 'v':
true_index = 1
labels.append(true_index)
images = tf.constant(images)
labels = tf.constant(labels)
images = tf.random_shuffle(images, seed=0)
labels = tf.random_shuffle(labels, seed=0)
data = tf.data.Dataset.from_tensor_slices((images, labels))
data = data.shuffle(len(testImg))
data = data.map(process, num_parallel_calls=16)
data = data.prefetch(buffer_size=BATCH_SIZE * 8)
batched_data = data.apply(
tf.contrib.data.batch_and_drop_remainder(BATCH_SIZE)).repeat(
40) #num of epoch
iterator = tf.data.Iterator.from_structure(batched_data.output_types,
batched_data.output_shapes)
init_op = iterator.make_initializer(batched_data)
Y = tf.placeholder(tf.float32, shape=[
BATCH_SIZE,
], name='Y')
model = OpenNsfwModel()
model.build(weights_path=None, batchsize=BATCH_SIZE, tag='')
Y_pred = model.logits
# sup1 = model.sup1
# sup2 = model.sup2
# sup3 = model.sup3
# loss = supervision_loss(Y, Y_pred, sup1, sup2, sup3)
loss = log_loss(Y, Y_pred)
accuracy = evaluation(Y, Y_pred)
train_op = trainning(loss, LR)
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.6
step = 0
epoch = 0
aver_acc = 0
with tf.Session(config=config) as sess:
saver = tf.train.Saver(max_to_keep=0)
sess.run(tf.global_variables_initializer())
sess.run(init_op)
images, filenames, labels = iterator.get_next()
ckpt = tf.train.get_checkpoint_state(logs_train_dir)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print('global_step', global_step)
if global_step != '0':
step = int(global_step) + 1
saver.restore(sess, ckpt.model_checkpoint_path)
record_loss = 0
record_acc = 0
while True:
try:
print('step', step)
name, label_Y, input = sess.run([filenames, labels, images])
get_loss, get_op, get_acc = sess.run(
[loss, train_op, accuracy],
feed_dict={
model.input: input,
Y: label_Y
})
print('loss', get_loss, 'accuracy', get_acc)
record_loss = record_loss + get_loss
record_acc = record_acc + get_acc
aver_acc = aver_acc + get_acc
if (step + 1) % (len(testImg) / BATCH_SIZE) == 0:
epoch = epoch + 1
###save record
record_loss = float(record_loss) / (len(testImg) /
BATCH_SIZE)
record_acc = float(record_acc) / (len(testImg) /
BATCH_SIZE)
update_csv(record_loss, record_acc, epoch)
###
print('epoch', epoch)
print('train_learning_rate', LR)
checkpoint_path = os.path.join(logs_train_dir,
'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
step = step + 1
except tf.errors.OutOfRangeError:
sess.run(init_op)
break
print(float(aver_acc) / step)
f.write(response.content)
# ### Png to Jpg Image
# In[ ]:
pngs = glob('./*.png')
for j in pngs:
img = cv2.imread(j)
cv2.imwrite((j[:-3] + 'jpg'), img)
# ### Model Load and Build
# In[ ]:
model = OpenNsfwModel()
model.build(weights_path="data/open_nsfw-weights.npy",
input_type=InputType.BASE64_JPEG)
# In[ ]:
fn_load_image = None
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
# In[ ]:
with tf.Session() as sess:
jpgs = glob('./*.jpg')
for j in range(len(jpgs)):
if os.stat(jpgs[j]).st_size != 0:
import argparse
import tensorflow as tf
from model import OpenNsfwModel, InputType
from image_utils import create_yahoo_image_loader
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/classify', methods=['GET'])
def classify():
filename = request.args["image_path"]
image = create_yahoo_image_loader()(filename)
predictions = sess.run(model.predictions, feed_dict={model.input: image})
# print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
predictions = predictions[0].tolist()
return jsonify(dict(sfw=predictions[0], nsfw=predictions[1]))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("-p", "--port", default=8082, help="server http port")
args = parser.parse_args()
model = OpenNsfwModel()
with tf.compat.v1.Session() as sess:
model.build(weights_path="data/open_nsfw-weights.npy", input_type=InputType["TENSOR"])
sess.run(tf.compat.v1.global_variables_initializer())
app.run(port=args.port)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
"path",
help="Path to the input images. Only jpeg images are supported.")
parser.add_argument("-b",
"--bucket",
required=True,
help="AWS S3 bucket name")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-o",
"--output",
required=True,
help="Path to output result file")
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-t",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
args = parser.parse_args()
s3 = boto3.client('s3')
bucket_name = ''
for bucket in s3.list_buckets().get('Buckets'):
if bucket.get('Name') == args.bucket:
bucket_name = bucket.get('Name')
if not bucket_name:
print("Bucket {} not available".format(args.bucket))
exit(-1)
images = []
next_token = ''
while True:
if next_token:
response = s3.list_objects_v2(Bucket=bucket_name,
Delimiter='|',
EncodingType='url',
MaxKeys=1000,
Prefix=args.path,
ContinuationToken=next_token,
FetchOwner=False)
else:
response = s3.list_objects_v2(Bucket=bucket_name,
Delimiter='|',
EncodingType='url',
MaxKeys=1000,
Prefix=args.path,
FetchOwner=False)
content = response.get('Contents')
next_token = response.get('NextContinuationToken')
for item in content:
images.append(item.get('Key'))
if not next_token:
break
print(next_token)
# if len(images) > 100:
# break
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
output = open(args.output, "a")
for item in images:
temp_file = tempfile.mkstemp()
s3.download_file(bucket_name, item, temp_file[1])
try:
image = fn_load_image(temp_file[1])
except IOError:
print("Read Image Error")
pass
predictions = sess.run(model.predictions,
feed_dict={model.input: image})
output.write(
"https://www.themebeta.com/media/cache/400x225/files/{}, {}\r\n"
.format(item, predictions[0][0]))
os.remove(temp_file[1])
print(
"Results for https://www.themebeta.com/media/cache/400x225/files/{} : {}"
.format(item, predictions[0][0]))
output.close()
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("-s", "--source", required=True,
help="Folder containing the images to classify")
parser.add_argument("-o", "--output_file", required=True,
help="Output file path")
parser.add_argument("-m", "--model_weights", required=True,
help="Path to trained model weights file")
parser.add_argument("-b", "--batch_size", help="Number of images to \
classify simultaneously.", type=int, default=64)
parser.add_argument("-l", "--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
args = parser.parse_args()
batch_size = args.batch_size
output_file = args.output_file
input_type = InputType.TENSOR
model = OpenNsfwModel()
filenames = glob.glob(args.source + "/*.jpg")
num_files = len(filenames)
num_batches = int(num_files / batch_size)
print("Found", num_files, " files")
print("Split into", num_batches, " batches")
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
batch_iterator = None
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
batch_iterator = create_tf_batch_iterator(filenames, batch_size)
else:
fn_load_image = create_yahoo_image_loader(expand_dims=False)
batch_iterator = create_batch_iterator(filenames, batch_size,
fn_load_image)
with tf.Session(graph=tf.Graph(), config=config) as session:
model.build(weights_path=args.model_weights,
input_type=input_type)
session.run(tf.global_variables_initializer())
with tqdm(total=num_files) as progress_bar:
with open(output_file, 'w') as o:
o.write('File\tSFW Score\tNSFW Score\n')
for batch_num, images in enumerate(batch_iterator):
predictions = \
session.run(model.predictions,
feed_dict={model.input: images})
fi = (batch_num * batch_size)
for i, prediction in enumerate(predictions):
filename = os.path.basename(filenames[fi + i])
o.write('{}\t{}\t{}\n'.format(filename,
prediction[0],
prediction[1]))
progress_bar.update(len(images))
parser.add_argument("-o", "--optimize", action='store_true',
default=False,
help="Optimize graph for inference")
parser.add_argument("-f", "--freeze", action='store_true',
required=False, default=False,
help="Freeze graph: convert variables to ops")
parser.add_argument("-t", "--text", action='store_true',
required=False, default=False,
help="Write graph as binary (.pb) or text (pbtext)")
args = parser.parse_args()
model = OpenNsfwModel()
export_base_path = args.target
do_freeze = args.freeze
do_optimize = args.optimize
as_binary = not args.text
input_type = InputType[args.input_type.upper()]
input_node_name = 'input'
output_node_name = 'predictions'
base_name = 'open_nsfw'
checkpoint_path = os.path.join(export_base_path, base_name + '.ckpt')
if as_binary:
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file", help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m", "--model_weights", required=True,
help="Path to trained model weights file")
parser.add_argument("-l", "--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-t", "--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()])
args = parser.parse_args()
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
image = fn_load_image(args.input_file)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(args.input_file))
print(predictions[0][0])
print(predictions[0][1])
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
# SFW : Safe For Work , NSFW : Not Safe For Work
nude_json = {'SFW' : predictions[0][0] , 'NSFW' : predictions[0][1] }
result= json.dumps(nude_json, cls=MyEncoder)
loaded_json = json.loads(result)
#for x in loaded_json:
# print("%s: %f" % (x, loaded_json[x]))
print(loaded_json)
f = open('data.txt', 'r+')
f.truncate()
with open('data.txt', 'w') as outfile:
json.dump(loaded_json, outfile)
return loaded_json
def main(argv):
parser = argparse.ArgumentParser()
args = parser.parse_args()
# args.input_file = "yyy-1.jpg"
# args.input_file = "no-sexy.jpg"
# args.input_file = "zzpic19597.jpg"
args.input_file = "sexy.jpg" # 输入图像
print('[Info] 测试图像: {}'.format(args.input_file))
args.image_loader = IMAGE_LOADER_YAHOO
args.input_type = InputType.TENSOR.name.lower()
args.model_weights = "data/open_nsfw-weights.npy"
model = OpenNsfwModel()
fn_load_image = None
input_type = InputType[args.input_type.upper()]
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
fn_load_image = lambda filename: np.array([base64.urlsafe_b64encode(open(filename, "rb").read())])
with tf.Session() as sess:
model.build(weights_path=args.model_weights, input_type=input_type)
sess.run(tf.global_variables_initializer())
print('\n[Info] 原始版本')
image = fn_load_image(args.input_file) # 源图像处理格式
model_predict(sess, model, image, args.input_file) # 第2个版本
print('\n[Info] 重写OpenCV版本')
img_np = cv2.imread(args.input_file)
img_np = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)
image_v2 = process_img_opencv(img_np)
model_predict(sess, model, image_v2, args.input_file) # 第2个版本
# 存储模型的逻辑
# print('\n[Info] 存储模型')
# save_model(sess, model)
print('\n[Info] base64模型版本')
img_np = cv2.imread(args.input_file)
img_np = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)
img_np = process_img_opencv(img_np)
print('[Info] Img: {}'.format(img_np.shape))
img_b64 = base64.urlsafe_b64encode(img_np) # 转换base64
img_tf = image_decode(img_b64)
print('[Info] tf shape: {}'.format(img_tf.shape))
img_np = tf.Session().run(img_tf)
print('[Info] tf->np shape: {}'.format(img_np.shape))
export_path = "data/model-tf" # 模型文件
with tf.Session(graph=tf.Graph()) as sess:
tf.saved_model.loader.load(sess, ["serve"], export_path)
graph = tf.get_default_graph()
print(graph.get_operations())
res = sess.run('predictions:0',
feed_dict={'input:0': img_np})
print('[Info] 最终结果: {}'.format(res))
print('[Info] 性感值: {}'.format(res[0][1] * 100.0))
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-i",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type")
args = parser.parse_args()
model = OpenNsfwModel()
frameTotal = 0
frameNsfw = 0
with tf.compat.v1.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(
tf.Session(graph=tf.Graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.compat.v1.global_variables_initializer())
#image = fn_load_image(args.input_file)
videoFile = args.input_file
cap = cv2.VideoCapture(videoFile)
frameRate = cap.get(5) #frame rate
while (cap.isOpened()):
frameId = cap.get(1) #current frame number
ret, frame = cap.read()
if (ret != True):
break
if (frameId % math.floor(frameRate) == 0):
cv2.imwrite('./images/temp.jpg', frame)
image = fn_load_image('./images/temp.jpg')
frameTotal = frameTotal + 1
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
if (predictions[0][1] >= 0.50):
frameNsfw = frameNsfw + 1
#print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
cap.release()
if (frameNsfw > 0):
print("NSFW")
else:
print("SFW")
print(str((frameNsfw / frameTotal) * 100))
# and initialize the FPS counter
print("[INFO] starting video stream ...")
vs = VideoStream(usePiCamera=True).start()
time.sleep(2.0)
# tensor flow loader options
IMAGE_LOADER_TENSORFLOW = "tensorflow"
IMAGE_LOADER_YAHOO = "yahoo"
MODEL = "open_nsfw-weights.npy"
INPUT_TYPE = "tensor"
image_loader = IMAGE_LOADER_YAHOO
print("[INFO] loading model ...")
now = time.time()
model = OpenNsfwModel()
start_time = time.time()
total_time = 0
sess = tf.Session()
input_type = InputType[INPUT_TYPE.upper()]
model.build(weights_path=MODEL, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
fn_load_image = create_yahoo_image_loader()
else:
print("parameter error")
elif INPUT_TYPE == 'BASE64_JPEG':
if FN_LOAD_IMAGE == IMAGE_LOADER_YAHOO:
print("parameter mismatch")
elif FN_LOAD_IMAGE == IMAGE_LOADER_TENSORFLOW:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
else:
print("parameter error")
else:
print("parameter error")
model = OpenNsfwModel()
input_type = InputType[INPUT_TYPE]
model.build(weights_path="data/open_nsfw-weights.npy", input_type=input_type)
sess = tf.Session()
def process_start(conn, addr):
logging.info("Connection address:" + str(addr))
rec_d = bytes([])
try:
while True:
data = conn.recv(BUFSIZ)
if not data or len(data) == 0:
break
else:
rec_d = rec_d + data
import argparse
import tensorflow as tf
import io
from model import OpenNsfwModel, InputType
import flask
from PIL import Image
import numpy as np
import skimage
import skimage.io
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
model_weights_path = 'data/open_nsfw-weights.npy'
model = OpenNsfwModel()
VGG_MEAN = [104, 117, 123]
img_width, img_height = 224, 224
app = flask.Flask(__name__)
# 将RGB按照BGR重新组装，然后对每一个RGB对应的值减去一定阈值
def prepare_image(image):
H, W, _ = image.shape
h, w = (img_width, img_height)
h_off = max((H - h) // 2, 0)
w_off = max((W - w) // 2, 0)
class NSFW:
def __init__(self):
self.fn_load_image = None
self.sess = None
self.model = OpenNsfwModel()
self.data_path = None
def session_run(self, source_type):
with tf.compat.v1.Session() as self.sess:
input_type = InputType[InputType.TENSOR.name.lower().upper()]
self.model.build(
weights_path='data/open_nsfw-weights.npy', input_type=input_type)
if input_type == InputType.TENSOR:
if IMAGE_LOADER_YAHOO == IMAGE_LOADER_TENSORFLOW:
self.fn_load_image = create_tensorflow_image_loader(
tf.Session(graph=tf.Graph()))
else:
self.fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
self.fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
self.sess.run(tf.compat.v1.global_variables_initializer())
# ======
data_txt = pd.read_table(
self.data_path, sep='\t', header=None).values.tolist()
data_result = []
for d in data_txt:
urls = get_urls(str(d[0]))
# print('网站 = ', str(d[0]), '图片数量:', len(urls))
if len(urls) > 0:
treu_sum = 0
for url in urls:
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36 QIHU 360SE'}
try:
res = requests.get(
url, headers=headers, timeout=20)
except:
continue
with open('img/text.jpg', 'wb') as f:
f.write(res.content)
f.close()
try:
image = self.fn_load_image('img/text.jpg')
except:
continue
predictions = self.sess.run(self.model.predictions, feed_dict={
self.model.input: image})
# print(float(predictions[0][1]), type(float(predictions[0][1])))
if float(predictions[0][1]) >= 0.8:
treu_sum += 1
if treu_sum / len(urls) >= 0.2:
data_result.append(str(d[0]))
sday = time.strftime(
'%Y-%m-%d', time.localtime(time.time()))
# print("INSERT INTO `pornographic_website_detection_zsf` (`sday`, `type`, `url`) VALUES ('" + sday + "', '"+source_type+"', '" + str(d[0]) + "' ,'" + str(d[1]) + "')")
# mysql_insert("INSERT INTO `pornographic_website_detection_zsf` (`sday`, `type`, `url`, `sum`) VALUES ('" +
sday + "', '"+source_type+"', '" + str(d[0]) + "' ,'" + str(d[1]) + "')")
print('网站 = ', str(d[0]), '图片数量:', len(urls), '色情图片情况', treu_sum, len(urls) - treu_sum, '占比:', treu_sum / len(urls))
return data_result
def __init__(self):
self.fn_load_image = None
self.sess = None
self.model = OpenNsfwModel()
self.data_path = None
parser.add_argument("target", help="output directory")
parser.add_argument("-v",
"--export_version",
help="export model version",
default="1")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
args = parser.parse_args()
model = OpenNsfwModel()
export_base_path = args.target
export_version = args.export_version
export_path = os.path.join(export_base_path, export_version)
with tf.Session() as sess:
model.build(weights_path=args.model_weights,
input_type=InputType.BASE64_JPEG)
sess.run(tf.global_variables_initializer())
builder = saved_model_builder.SavedModelBuilder(export_path)
builder.add_meta_graph_and_variables(
def classify_nsfw_lambda(imgs):
model = OpenNsfwModel()
with tf.Session() as sess:
def classity_nsfw(url):
if '/a/' in url:
return -1
if not (url.endswith(".gif") or url.endswith(".jpg") or url.endswith.("jpeg") or url.endswith(".png")):
return -1
print("Downloading from '{}'".format(url))
local_filename = url.split('/')[-1]
try:
r = requests.get(url, stream=True)
with open(local_filename, 'wb') as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk: # filter out keep-alive new chunks
f.write(chunk)
if '.gif' in local_filename:
print("gif found")
local_filename_gif = local_filename
local_filename = local_filename.replace('.gif', '.jpg')
print('calling convert {gif}[0] {jpg}'.format(gif=local_filename_gif, jpg=local_filename))
ret = subprocess.call('convert {gif}[0] {jpg}'.format(gif=local_filename_gif, jpg=local_filename), shell=True)
print('output: {}'.format(ret))
elif '.png' in local_filename:
print("png found")
local_filename_png = local_filename
local_filename = local_filename.replace('.png', '.jpg')
print('convert {png} {jpg}'.format(png=local_filename_png, jpg=local_filename))
ret = subprocess.call('convert {png} {jpg}'.format(png=local_filename_png, jpg=local_filename), shell=True)
print('output: {}'.format(ret))
image = fn_load_image(local_filename)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(local_filename))
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
return predictions[0][1]
except requests.exceptions.ConnectionError:
print("Connection Err")
return -1
except tf.errors.InvalidArgumentError:
print("Argument Err")
return -1
except (OSError, IOError) as e:
print("FIle Not Found Err")
return -1
finally:
dir_name = os.getcwd()
test = os.listdir(dir_name)
for item in test:
if item.endswith(".gif") or item.endswith(".jpg") or item.endswith(".png") or item.endswith("jpeg"):
os.remove(os.path.join(dir_name, item))
model.build(weights_path='data/open_nsfw-weights.npy', input_type=InputType[InputType.TENSOR.name.upper()])
fn_load_image = create_tensorflow_image_loader(sess)
sess.run(tf.global_variables_initializer())
outputObj = {'values': []}
for img in imgs:
p = classity_nsfw(img)
outputObj['values'].append(p)
return str(outputObj)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-t",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
args = parser.parse_args()
model = OpenNsfwModel()
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(sess)
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.global_variables_initializer())
images = []
images_names = []
for i in os.listdir(args.input_file):
images_names.append(i)
image_path = os.path.join(args.input_file, i)
image = fn_load_image(image_path)
if images == []:
images = image
print(image_path)
else:
images = np.concatenate((images, image), axis=0)
image = images
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
classify_to_folder(args, images_names, predictions)
default=InputType.TENSOR.name.lower(),
help=
"Input type. Warning: base64_jpeg does not work with the standard TFLite runtime since a lot of operations are not supported",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
args = parser.parse_args()
model = OpenNsfwModel()
export_path = args.target
input_type = InputType[args.input_type.upper()]
with tf.Session() as sess:
model.build(weights_path=args.model_weights, input_type=input_type)
sess.run(tf.global_variables_initializer())
converter = tf.contrib.lite.TFLiteConverter.from_session(
sess, [model.input], [model.predictions])
tflite_model = converter.convert()
with open(export_path, "wb") as f:
f.write(tflite_model)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("-s",
"--source",
required=True,
help="Folder containing the images to classify")
parser.add_argument("-o",
"--output_file",
required=True,
help="Output file path")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-b",
"--batch_size",
help="Number of images to \
classify simultaneously.",
type=int,
default=64)
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
args = parser.parse_args()
batch_size = args.batch_size
output_file = args.output_file
input_type = InputType.TENSOR
model = OpenNsfwModel()
filenames = glob.glob(args.source + "/*.jpg")
num_files = len(filenames)
num_batches = int(num_files / batch_size)
print("Found", num_files, " files")
print("Split into", num_batches, " batches")
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
batch_iterator = None
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
batch_iterator = create_tf_batch_iterator(filenames, batch_size)
else:
fn_load_image = create_yahoo_image_loader(expand_dims=False)
batch_iterator = create_batch_iterator(filenames, batch_size,
fn_load_image)
with tf.Session(graph=tf.Graph(), config=config) as session:
model.build(weights_path=args.model_weights, input_type=input_type)
session.run(tf.global_variables_initializer())
with tqdm(total=num_files) as progress_bar:
with open(output_file, 'w') as o:
o.write('File\tSFW Score\tNSFW Score\n')
for batch_num, images in enumerate(batch_iterator):
predictions = \
session.run(model.predictions,
feed_dict={model.input: images})
fi = (batch_num * batch_size)
for i, prediction in enumerate(predictions):
filename = os.path.basename(filenames[fi + i])
o.write('{}\t{}\t{}\n'.format(filename, prediction[0],
prediction[1]))
progress_bar.update(len(images))
def main(argv):
# parse inputs
parser = argparse.ArgumentParser()
parser.add_argument("input_file", help="Path to the input video.")
parser.add_argument("id_folder",
type=str,
nargs="+",
help="Folder containing ID folders")
args = parser.parse_args()
# initialize NSFW Model
model = OpenNsfwModel()
with tf.Graph().as_default():
with tf.Session() as sess:
# set variable defaults
videoFile = args.input_file
cap = cv2.VideoCapture(videoFile)
frameRate = cap.get(5) # get the frame rate
totalFrameCount = cap.get(7) # get the total number of frames
img_size = 64
margin = 0.4
frameNsfw = 0
isMinor = False
minorDetected = False
# set weights and initialize SFW model IsSFW
with tf.variable_scope('IsSFW'):
model.build(
weights_path="pretrained_models/open_nsfw-weights.npy")
fn_load_image = None
fn_load_image = create_yahoo_image_loader()
sess.run(tf.global_variables_initializer())
# initialize dlib face detector model and set variables
detector = dlib.get_frontal_face_detector()
model2 = WideResNet(img_size, 16, 8)()
model2.load_weights("pretrained_models/weights.29-3.76_utk.hdf5")
# initialize face identification model
mtcnn = detect_and_align.create_mtcnn(sess, None)
load_model("model/20170512-110547.pb")
threshold = 1.0
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
# Load anchor IDs for face identification model
id_data = IdData(args.id_folder[0], mtcnn, sess, embeddings,
images_placeholder, phase_train_placeholder,
threshold)
while (cap.isOpened()):
ret, frame = cap.read()
frameId = cap.get(1) # get the current frame number
if (ret !=
True): # if there is no video frame detected then exit
break
# write video frame to disk and load as an image
cv2.imwrite('./temp_files/temp.jpg', frame)
image = fn_load_image('./temp_files/temp.jpg')
# determine SFW status
predictions = sess.run(model.predictions,
feed_dict={model.input: image})
if (predictions[0][1] >= 0.50):
frameNsfw = frameNsfw + 1
display_lbl = "NSFW"
AlertColor = [0, 0, 255]
else:
display_lbl = "SFW"
AlertColor = [255, 0, 0]
# detect faces in dlib face detection model
image2 = frame
image2_h, image2_w, _ = np.shape(image2)
detected = detector(image2, 0)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected
) > 0: # one or more faces were found in the frame
for i, d in enumerate(detected):
# extract the coordinates of the face
x1, y1, x2, y2, w, h = d.left(), d.top(), d.right(
) + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), image2_w - 1)
yw2 = min(int(y2 + margin * h), image2_h - 1)
# draw a rectangle around the face
cv2.rectangle(image2, (x1, y1), (x2, y2), (255, 0, 0),
2)
faces[i, :, :, :] = cv2.resize(
image2[yw1:yw2 + 1, xw1:xw2 + 1, :],
(img_size, img_size))
# determine the height of the rectangle in case is near top of frame
rectangle_height = y2 - y1
# predict ages and genders of faces using dlib model
results = model2.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw predictions by faces using dlib model
for i, d in enumerate(detected):
isMinor = False
if (int(predicted_ages[i] < 18)
): # detect if a minor is present in the video
isMinor = True
minorDetected = True
label = "{},{},{}".format(
int(predicted_ages[i]),
"M" if predicted_genders[i][0] < 0.5 else "F",
"-MINOR" if isMinor else "")
draw_label(image2, (d.left(), d.top()), label,
rectangle_height)
# Locate faces and landmarks in frame for identification
face_patches, padded_bounding_boxes, landmarks = detect_and_align.detect_faces(
frame, mtcnn)
if len(face_patches) > 0:
face_patches = np.stack(face_patches)
feed_dict = {
images_placeholder: face_patches,
phase_train_placeholder: False
}
embs = sess.run(embeddings, feed_dict=feed_dict)
matching_ids, matching_distances = id_data.find_matching_ids(
embs)
for bb, landmark, matching_id, dist in zip(
padded_bounding_boxes, landmarks, matching_ids,
matching_distances):
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
cv2.putText(frame, matching_id,
(bb[0] + 30, bb[3] + 5), font, 1,
(255, 0, 255), 1, cv2.LINE_AA)
# display whether frame is SFW or not
percentageComplete = round((frameId) / (totalFrameCount) * 100)
display_lbl = display_lbl + " " + str(
percentageComplete) + "% fps= " + str(round(frameRate, 2))
size = cv2.getTextSize(display_lbl, cv2.FONT_HERSHEY_SIMPLEX,
0.4, 1)[0]
cv2.rectangle(image2, (1, 15 - size[1]), (1 + size[0], 20),
AlertColor, cv2.FILLED)
cv2.putText(image2,
display_lbl, (1, 19),
cv2.FONT_HERSHEY_SIMPLEX,
0.4, (255, 255, 255),
1,
lineType=cv2.LINE_AA)
# display the frame as processed as quickly as possible
cv2.imshow('frame2', image2)
cv2.waitKey(1)
# end of video
cap.release()
cv2.destroyAllWindows()
if os.path.isfile('temp_files/temp.jpg'):
os.remove("temp_files/temp.jpg")
# print summary
if totalFrameCount > 0:
if (frameNsfw > 0):
if (minorDetected):
print("This video contains minors, and " +
str(round((frameNsfw / totalFrameCount * 100), 1)) +
"% of the video contains NSFW elements.")
else:
print(
str(round((frameNsfw / totalFrameCount * 100), 1)) +
"% of the video contains NSFW elements.")
else:
print("Video is SFW.")
else:
print(
"No video frames were detected! Please check the file type or file name."
)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
help="Path to the input image.\
Only jpeg images are supported.")
parser.add_argument("-m",
"--model_weights",
required=True,
help="Path to trained model weights file")
parser.add_argument("-cb", "--callback", default='', help="Callback Url")
parser.add_argument("-l",
"--image_loader",
default=IMAGE_LOADER_YAHOO,
help="image loading mechanism",
choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
parser.add_argument("-i",
"--input_type",
default=InputType.TENSOR.name.lower(),
help="input type",
choices=[
InputType.TENSOR.name.lower(),
InputType.BASE64_JPEG.name.lower()
])
args = parser.parse_args()
model = OpenNsfwModel()
current_path = os.getcwd()
dir_path = '%s/image_temp' % (current_path)
if 'http' in args.input_file:
image_file_path = utils.download(args.input_file, dir_path)
logger.info("image download to: " + image_file_path)
else:
image_file_path = args.input_file
if '.jpg' not in image_file_path:
jpg_image_file_path = utils.convPNG2JPG(image_file_path)
if False == jpg_image_file_path:
logger.error('Conv Image Fail!' + image_file_path)
exit(1)
os.remove(image_file_path)
image_file_path = jpg_image_file_path
with tf.compat.v1.Session() as sess:
input_type = InputType[args.input_type.upper()]
model.build(weights_path=args.model_weights, input_type=input_type)
fn_load_image = None
if input_type == InputType.TENSOR:
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
fn_load_image = create_tensorflow_image_loader(
tf.Session(graph=tf.Graph()))
else:
fn_load_image = create_yahoo_image_loader()
elif input_type == InputType.BASE64_JPEG:
import base64
def fn_load_image(filename):
return np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
sess.run(tf.compat.v1.global_variables_initializer())
image = fn_load_image(image_file_path)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
logger.info("Results for '{}'".format(args.input_file))
logger.info(
"\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
if '' != args.callback:
param = {
'sfw': str(predictions[0][0]),
'nsfw': str(predictions[0][1])
}
ret = utils.get(args.callback, param)
logger.info(ret)
if 'http' in args.input_file:
os.remove(image_file_path)
