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))
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):
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 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]))
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 get_tf_image(image_path):
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(image_path, "rb").read())])
print("predicting nsfw for image {}".format(image_path))
image = fn_load_image(image_path)
return image
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 __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 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):
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)
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):
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)
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",
"--frozen_graph_file",
required=True,
help="The frozen graph def file")
parser.add_argument("-b",
"--batch_size",
help="Number of images to \
classify simultaneously.",
type=int,
default=64)
args = parser.parse_args()
batch_size = args.batch_size
output_file = args.output_file
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
fn_load_image = create_yahoo_image_loader(expand_dims=False)
batch_iterator = create_batch_iterator(filenames, batch_size,
fn_load_image)
trt_graph = get_frozen_graph(args.frozen_graph_file)
# Create session and load graph
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
tf_sess = tf.Session(config=tf_config)
tf.import_graph_def(trt_graph, name='')
input_node_name = 'input'
output_node_name = 'predictions'
# input and output tensor names.
input_tensor_name = input_node_name + ":0"
output_tensor_name = output_node_name + ":0"
print("input_tensor_name: {}\noutput_tensor_name: {}\n".format(
input_tensor_name, output_tensor_name))
output_tensor = tf_sess.graph.get_tensor_by_name(output_tensor_name)
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 = \
tf_sess.run(output_tensor,
feed_dict={input_tensor_name: 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 input
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
help="Path to the input video.\
Only mp4 is supported.")
args = parser.parse_args()
# initialize NSFW Model
model = OpenNsfwModel()
# initialize variables
frameTotal = 0
frameNsfw = 0
frame_skip = 0
# load video (argument)
videoFile = args.input_file
st = args.input_file
st = st[:-4]
outfilename = st + "_Clean.avi"
with tf.Session() as sess:
# set weights and initialize SFW model
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())
cap = cv2.VideoCapture(videoFile)
frameRate = cap.get(5) #frame rate
ret, frame = cap.read()
height, width, nchannels = frame.shape
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter(outfilename, fourcc, math.floor(frameRate),
(width, height))
global flag
global frame_skip
while (True):
ret, frame = cap.read()
if (ret != True): # if there is no video frame detected then exit
break
else:
cv2.imwrite('./temp_files/temp.jpg', frame)
image = fn_load_image('./temp_files/temp.jpg')
frameTotal = frameTotal + 1
predictions = sess.run(model.predictions,
feed_dict={model.input: image})
if (predictions[0][1] <= 0.50):
out.write(frame)
else:
frameNsfw = frameNsfw + 1
# print summary after program runs
if (frameNsfw > 0):
print("Video contained NSFW content.")
else:
print("Video is SFW.")
print((frameNsfw / frameTotal) * 100)
cap.release()
out.release()
print("Done")
def extract_nsfw_features(labeled_image_root_dir,
image_input_type,
image_loader_type,
model_dir,
has_supplement=False,
phase='train',
return_image_files=False):
# load train data set
with utils.timer('Load image files'):
if (phase == 'train'):
image_files, labels = data_utils.load_files(
labeled_image_root_dir, train_data_source, sample_rate)
else:
image_files, labels = data_utils.load_files(
labeled_image_root_dir, test_data_source, sample_rate)
if (has_supplement):
for part in [
'test_0819_part1_1', 'test_0819_part1_2',
'test_0819_part1_3', 'test_0819_part3_1'
]:
supplement_dir = '{}/{}'.format(
'/'.join(labeled_image_root_dir.split('/')[:-1]), part)
image_files_supplement, labels_supplement = data_utils.load_files(
supplement_dir, 'test_0819_part1', sample_rate)
print('before supplement %s' % len(image_files))
image_files = np.concatenate(
[image_files, image_files_supplement], axis=0)
print('after supplement %s' % len(image_files))
labels = np.concatenate([labels, labels_supplement], axis=0)
print('image files %s' % len(image_files))
X_train = []
y_train = []
# transform original image into nsfw features
with tf.Session(graph=tf.Graph()) as sess:
input_type = InputType[image_input_type.upper()]
# function of loading image
fn_load_image = None
if input_type == InputType.TENSOR:
if image_loader_type == 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:
fn_load_image = lambda filename: np.array(
[base64.urlsafe_b64encode(open(filename, "rb").read())])
# load model
with utils.timer('Load model'):
tf.saved_model.loader.load(sess, ["serve"], model_dir)
graph = tf.get_default_graph()
# extract tensor from graph
input_image = graph.get_tensor_by_name("input:0")
projected_features = graph.get_tensor_by_name('nsfw_features:0')
predict_proba = graph.get_tensor_by_name("predictions:0")
nsfw_batch_size = 512
# extract projection features
with utils.timer('Projection with batching'):
start = 0
end = start + nsfw_batch_size
while (start < len(image_files)):
if (end > len(image_files)):
end = len(image_files)
with utils.timer('batch(%s) prediction' % nsfw_batch_size):
batch_images = np.array([
fn_load_image(image_files[i]).tolist()
for i in range(start, end)
])
X_train.extend(
sess.run(projected_features,
feed_dict={
input_image: batch_images
}).tolist())
y_train.extend(labels[start:end])
print('projection %s done.' % end)
start = end
end = start + nsfw_batch_size
del batch_images
gc.collect()
sess.close()
# sanity check
assert len(y_train) == len(labels)
if (return_image_files == True):
return np.array(X_train), np.array(y_train), image_files
else:
return np.array(X_train), np.array(y_train)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("input_file",
default="urls.txt",
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())
urls_gen = faked_call_4_urls()
for urls in urls_gen:
for url in urls:
md5 = hashlib.md5(url.encode('utf-8')).hexdigest()
name = path + "/" + md5 + '.jpg'
if os.path.exists(name) == False:
print("begin to download imgurl=", url)
name = safe_download("temp_image", url)
else:
print("exist file name=" + name)
image = read_frame_from_video(name)
print("need to detect image size ", len(image))
predictions = sess.run(model.predictions,
feed_dict={model.input: image})
write_to_file(url + "\t" + str(max_prob(predictions)))
print(url + "\t" + str(max_prob(predictions)))
if os.path.exists(name) == True:
os.remove(name)
print("delete file name=" + 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("-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))
parser.add_argument("-t", "--target", required=True,
choices=['ml-engine', 'tf-serving'],
help="Create json request for ml-engine or tensorflow-serving")
args = parser.parse_args()
target = args.target
input_type = InputType[args.input_type.upper()]
image_data = None
if input_type == InputType.TENSOR:
fn_load_image = None
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
with tf.Session() as sess:
fn_load_image = create_tensorflow_image_loader(sess)
sess.run(tf.global_variables_initializer())
image_data = fn_load_image(args.input_file)[0]
else:
image_data = create_yahoo_image_loader(tf.Session(graph=tf.Graph()))(args.input_file)[0]
elif input_type == InputType.BASE64_JPEG:
import base64
image_data = base64.urlsafe_b64encode(open(args.input_file, "rb").read()).decode("ascii")
if target == "ml-engine":
print(json.dumps({PREDICT_INPUTS: image_data}, cls=NumpyEncoder))
elif target == "tf-serving":
print(json.dumps({"instances": [image_data]}, cls=NumpyEncoder))
def main():
model = OpenNsfwModel()
with tf.Session() as sess:
# input_type = InputType[args.input_type.upper()]
input_type = InputType.TENSOR ###############
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())])
sess.run(tf.global_variables_initializer())
##########
result_list = []
from os_utils import get_file_list
file_list = get_file_list("dataset")
remark = []
for file in file_list:
input_image_file = os.path.join(".",file)
if input_image_file[-4::] == ".png":
from skimage import io
from skimage.color import rgba2rgb
im = io.imread(file)
im_rgb = rgba2rgb(im)
io.imsave("current_temp.jpeg", im_rgb)
input_file = "current_temp.jpeg"
else:
input_file = file
image = fn_load_image(input_file)
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
# print(predictions[0])
result_list.append(predictions[0][1])
print("Results for '{}'".format(input_file))
print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
if predictions[0][1] >= 0.03:
print("\t低俗图片")
remark.append("低俗")
else:
print("\t不是低俗图片")
remark.append("正常")
print(predictions[0][1])
os.system("rm -rf current_temp.jpeg")
result_dict = {"image_list":file_list, "result_list":result_list, "remark":remark}
return result_dict
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):
parser = argparse.ArgumentParser()
parser.add_argument(
'-i',
"--input_dir",
default=config.test_data_set[data_source],
help="Path to the input image. Only jpeg images are supported.")
parser.add_argument("-m",
"--model_weights",
default=config.nsfw_model_weight_file,
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()
with utils.timer('Load image files'):
image_files, labels = data_utils.load_files(args.input_dir,
data_source, sample_rate)
print('image files %s' % len(image_files))
model = OpenNsfwModel()
predictions = []
with tf.Session() as sess:
input_type = InputType[args.input_type.upper()]
with utils.timer('Load model weight'):
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())
with utils.timer('Prediction'):
start = 0
end = start + config.batch_size
while (start < len(image_files)):
if (end > len(image_files)):
end = len(image_files)
with utils.timer('Batch[%s] prediction' % config.batch_size):
batch_images = [
fn_load_image(image_files[i])
for i in range(start, end)
]
predictions.extend(
sess.run(model.predictions,
feed_dict={model.input: batch_images})[:, 1])
print('Prediction %s done.' % end)
start = end
end = start + config.batch_size
# save
PredictOutputFile = '%s/%s.csv' % (config.TestOutputDir, data_source)
with utils.timer('Save predictions'):
data_utils.save_predictions(image_files, labels, predictions,
PredictOutputFile)
# visualization on threshold for f1/precision/recall
if (data_source == 'hisotry'):
output_image_file = '%s/%s_vs_threshold.jpg' % (config.TestOutputDir,
level)
with utils.timer('Save visualization for threshold'):
plot_utils.threshold_vs_toxic(labels, predictions, level,
output_image_file)
def nsfw_main(setting_file="tmp.csv"):
data = pd.read_csv(setting_file, names=['location', 'nsfw'])
tarray = []
# 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()
config = tf.ConfigProto(gpu_options=tf.GPUOptions(
visible_device_list="0", # specify GPU number
allow_growth=True))
with tf.Session(config=config) 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())
count = 1
for index, row in data.iterrows():
# if count > 100:
# break
start = time.time()
image = fn_load_image(row[0])
predictions = \
sess.run(model.predictions,
feed_dict={model.input: image})
print("Results for '{}'".format(row[0]))
print(
"\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
tarray.append(predictions[0][1])
print("elapsed_time:{0}".format(time.time() - start) + "[sec]")
count += 1
data['nsfw'] = tarray
data.to_csv(setting_file, index=False, header=False)
print(data)
return 0
tf_sess = tf.Session(config=tf_config)
tf.import_graph_def(frozen_graph, name='')
# input and output tensor names.
input_tensor_name = input_node_name + ":0"
output_tensor_name = output_node_name + ":0"
print("input_tensor_name: {}\noutput_tensor_name: {}\n".format(
input_tensor_name, output_tensor_name))
print("get_tensor_by_name\n")
output_tensor = tf.get_default_graph().get_tensor_by_name(output_tensor_name)
print("fn_load_image\n");
fn_load_image = create_yahoo_image_loader()
filenames = glob.glob(args.images + "/*.jpg")
num_files = len(filenames)
begin = datetime.datetime.now()
with tqdm(total=num_files) as progress_bar:
for img_file in filenames:
img = fn_load_image(img_file)
# print("load '{}' file\n".format(img_file))
feed_dict = {
input_tensor_name: img
}
preds = tf_sess.run(output_tensor, feed_dict)
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("-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(
"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()
choices=['ml-engine', 'tf-serving'],
help="Create json request for ml-engine or tensorflow-serving")
args = parser.parse_args()
target = args.target
input_type = InputType[args.input_type.upper()]
image_data = None
if input_type == InputType.TENSOR:
fn_load_image = None
if args.image_loader == IMAGE_LOADER_TENSORFLOW:
with tf.Session() as sess:
fn_load_image = create_tensorflow_image_loader(sess)
sess.run(tf.global_variables_initializer())
image_data = fn_load_image(args.input_file)[0]
else:
image_data = create_yahoo_image_loader(
tf.Session(graph=tf.Graph()))(args.input_file)[0]
elif input_type == InputType.BASE64_JPEG:
import base64
image_data = base64.urlsafe_b64encode(
open(args.input_file, "rb").read()).decode("ascii")
if target == "ml-engine":
print(json.dumps({PREDICT_INPUTS: image_data}, cls=NumpyEncoder))
elif target == "tf-serving":
print(json.dumps({"instances": [image_data]}, cls=NumpyEncoder))
