def load_model (args):
if args.model == 'inception':
model = InceptionV3(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'xception':
model = Xception(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
model = InceptionResNetV2(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'mobilenet':
model = MobileNet(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'mobilenet2':
model = MobileNetV2(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'nasnet':
model = NASNetLarge(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'resnet':
model = ResNet50(include_top=True, weights='imagenet')
preprocess_mode='caffe'
elif args.model == 'vgg16':
model = VGG16(include_top=True, weights='imagenet')
preprocess_mode='caffe'
elif args.model == 'vgg19':
model = VGG19(include_top=True, weights='imagenet')
preprocess_mode='caffe'
else:
print ("Model not found")
return model,preprocess_mode
def __init__(self):
# load config file
config = json.load(open("model/config.json"))
# get the image processor
self._imageProcessor = ImageProcessor(config)
# load the DL model
self._model = Xception()
self._model.load_weights('model/model.h5')
self._model._make_predict_function()
def Run(self, img_path, model_name):
# config variables
weights = 'imagenet'
include_top = 0
train_path = 'jpg'
classfier_file = 'output/flowers_17/' + model_name + '/classifier.cpickle'
# create the pretrained models
# check for pretrained weight usage or not
# check for top layers to be included or not
if model_name == "vgg16":
from vgg16 import VGG16, preprocess_input
base_model = VGG16(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "vgg19":
from vgg19 import VGG19, preprocess_input
base_model = VGG19(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "resnet50":
from resnet50 import ResNet50, preprocess_input
base_model = ResNet50(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
image_size = (224, 224)
elif model_name == "inceptionv3":
from inception_v3 import InceptionV3, preprocess_input
base_model = InceptionV3(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('mixed9').output)
image_size = (299, 299)
elif model_name == "xception":
from xception import Xception, preprocess_input
base_model = Xception(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
image_size = (299, 299)
else:
base_model = None
img = image.load_img(img_path, target_size=image_size)
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array = preprocess_input(img_array)
feature = model.predict(img_array)
feature = feature.flatten()
with open(classfier_file, 'rb') as f:
model2 = pickle.load(f)
pred = model2.predict(feature)
prob = model2.predict_proba(np.atleast_2d(feature))[0]
return pred, prob[0]
def init_xcep_FAD(self):
self.FAD_xcep = Xception(self.num_classes)
# To get a good performance, using ImageNet-pretrained Xception model is recommended
state_dict = get_xcep_state_dict()
conv1_data = state_dict['conv1.weight'].data
self.FAD_xcep.load_state_dict(state_dict, False)
# copy on conv1
# let new conv1 use old param to balance the network
self.FAD_xcep.conv1 = nn.Conv2d(12, 32, 3, 2, 0, bias=False)
for i in range(4):
self.FAD_xcep.conv1.weight.data[:, i * 3:(i + 1) *
3, :, :] = conv1_data / 4.0
def main_worker(local_rank, args):
args.local_rank = local_rank
# prepare dist environment
dist.init_process_group(backend='nccl',
rank=args.local_rank,
world_size=args.world_size)
torch.cuda.set_device(args.local_rank)
network = Xception(num_classes=cfg.num_classes)
network = network.cuda()
network = torch.nn.parallel.DistributedDataParallel(
network, device_ids=[args.local_rank])
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(network.parameters(),
lr=cfg.lr_init,
momentum=cfg.SGD_momentum)
dataloader_train = create_dataset_pytorch_imagenet_dist_train(
data_path=args.data_path + 'train',
local_rank=local_rank,
n_workers=cfg.n_workers)
dataloader_test = create_dataset_pytorch_imagenet(
data_path=args.data_path + 'val',
is_train=False,
n_workers=cfg.n_workers)
step_per_epoch = len(dataloader_train)
scheduler = optim.lr_scheduler.StepLR(optimizer,
gamma=cfg.lr_decay_rate,
step_size=cfg.lr_decay_epoch *
step_per_epoch)
summary_writer = None
if local_rank == 0:
summary_writer = SummaryWriter(log_dir='./summary')
trainer = Trainer(network=network,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
dataloader_train=dataloader_train,
dataloader_test=dataloader_test,
summary_writer=summary_writer,
epoch_size=cfg.epoch_size,
ckpt_path=args.ckpt_path,
local_rank=local_rank)
for epoch_id in range(cfg.epoch_size):
trainer.step()
if local_rank == 0:
summary_writer.close()
def getNet():
input1 = Input(shape=(1920,1920,3), name="input1")
x=SeparableConv2D(3,(3,3),strides=2,padding="same",activation="relu")(input1)
x=SeparableConv2D(3,(3,3),strides=2,padding="same",activation="relu")(x)
# x=BatchNormalization()(x)
x=Xception(weights=None,input_shape=(480,480,3),include_top=False)(x)
# x=NASNetLarge(weights="imagenet",input_shape=(331,331,3),include_top=False)(x)
x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
x=GlobalAveragePooling2D()(x)
x=Dense(1,activation="sigmoid")(x)
# 编译模型
model = Model(inputs=input1, outputs=x)
return model
def main():
# parser = argparse.ArgumentParser(description = 'Deep Learning Framework 1 Argument')
# parser.add_argument('--epochs', type = int, default = 100, metavar = 'N', help = 'number of epochs to train and test the model (default=100)')
# args = parser.parse_args()
transform = transforms.Compose([
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor(),
transforms.Normalize([
0.4161,
], [
0.1688,
]),
])
train_dataset = datasets.ImageFolder('cropped_trainset', transform)
test_dataset = datasets.ImageFolder('cropped_testset', transform)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=3,
shuffle=True,
num_workers=2)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
num_workers=2)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Xception().to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = StepLR(optimizer, step_size=1, gamma=0.8)
# set you own epoch
for epoch in range(100):
train(model, device, train_loader, optimizer, epoch)
test(model, device, test_loader)
"""
use train and test function to train and test your model
"""
save_models(model)
model = densenet161_model(IMG_SIZE,
IMG_SIZE,
channel,
num_classes=num_classes)
elif (options.model == 'densenet169'):
model = densenet169_model(IMG_SIZE,
IMG_SIZE,
channel,
num_classes=num_classes)
elif (options.model == 'InceptionResnet'):
model = InceptionResNetV2(IMG_SIZE,
IMG_SIZE,
channel,
num_classes=num_classes)
elif (options.model == 'xception'):
model = Xception(IMG_SIZE, IMG_SIZE, channel, num_classes=num_classes)
elif (options.model == 'inceptionv4'):
model = inception_v4_model(IMG_SIZE,
IMG_SIZE,
channel,
num_classes=num_classes)
print(model.summary())
#data generator
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
def train_factory(MODEL_NAME):
config = tf.ConfigProto()
config.gpu_options.allocator_type = 'BFC'
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
# model = CCR(input_shape=(img_width,img_height,1),classes=charset_size)
# model = LeNet.build(width=img_width, height=img_height, depth=1, classes=charset_size)
# model = ResNet.build_model(SHAPE=(img_width,img_height,1), classes=charset_size)
# vgg net 5
# MODEL_PATH='trained_model/vggnet5.hdf5'
# model=VGGNet5.vgg(input_shape=(img_width,img_height,1),classes=charset_size)
model=None
if(MODEL_NAME=='inception_resnet_v2'):
model=InceptionResNetV2.inception_resnet_v2(input_shape=(img_width,img_height,3),classes=charset_size,weights='./trained_model/inception_resnet_v2/inception_resnet_v2.12-0.8244.hdf5')
elif(MODEL_NAME=='xception'):
# xeception
model=Xception.Xception((img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='mobilenet_v2'):
#mobilenet v2
model=MobileNetv2.MobileNet_v2((img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='inception_v3'):
#mobilenet v2
model=Inception_v3.inception((img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='vgg16'):
model=VGGNet.vgg(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='vgg19'):
model=VGG19.VGG19(input_shape=(img_width,img_height,3),classes=charset_size,weights='weights/vgg19_weights_tf_dim_ordering_tf_kernels.h5')
elif(MODEL_NAME=='resnet50'):
model=ResNet50.resnet(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='inception_v4'):
model=inception_v4.inception_v4(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='resnet34'):
model=ResNet34.ResNet34(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='densenet121'):
model=DenseNet.DenseNet(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='densenet161'):
model=DenseNet.DenseNet(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='shufflenet_v2'):
model=ShuffleNetV2.ShuffleNetV2(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='resnet_attention_56'):
model=Resnet_Attention_56.Resnet_Attention_56(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='squeezenet'):
model=SqueezeNet.SqueezeNet(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='seresnet50'):
model=SEResNet50.SEResNet50(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='se_resnext'):
model=SEResNext.SEResNext(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='nasnet'):
model=NASNet.NASNetLarge(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='custom'):
model=Custom_Network.Custom_Network(input_shape=(img_width,img_height,3),classes=charset_size)
elif(MODEL_NAME=='resnet18'):
model=ResnetBuilder.build_resnet_18(input_shape=(img_width,img_height,3),num_outputs=charset_size)
print(model.summary())
train(model,MODEL_NAME)
def load_model (args):
if args.output_layer == '0':
if args.model == 'inception':
model = InceptionV3(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'xception':
model = Xception(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
model = InceptionResNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'mobilenet':
model = MobileNet(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'mobilenet2':
model = MobileNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'nasnet':
model = NASNetLarge(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'resnet':
model = ResNet50(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
elif args.model == 'vgg16':
model = VGG16(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
elif args.model == 'vgg19':
model = VGG19(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
else:
print ("Model not found")
return 0
else:
if args.model == 'inception':
base_model = InceptionV3(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'xception':
base_model = Xception(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
base_model = InceptionResNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'mobilenet':
base_model = MobileNet(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'mobilenet2':
base_model = MobileNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'nasnet':
base_model = NASNetLarge(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'resnet':
base_model = ResNet50(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
elif args.model == 'vgg16':
base_model = VGG16(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
elif args.model == 'vgg19':
base_model = VGG19(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
else:
print ("Model not found")
return 0
return model,preprocess_mode
base_model = VGG19(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "resnet50":
base_model = ResNet50(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('flatten').output)
image_size = (224, 224)
elif model_name == "inceptionv3":
base_model = InceptionV3(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('mixed9').output)
image_size = (299, 299)
elif model_name == "xception":
base_model = Xception(weights=weights)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
image_size = (299, 299)
else:
base_model = None
# In[ ]:
# path to training dataset
train_labels = sorted(os.listdir(train_path))
# variables to hold features and labels
features = []
labels = []
def init_xcep(self):
self.xcep = Xception(self.num_classes)
# To get a good performance, using ImageNet-pretrained Xception model is recommended
state_dict = get_xcep_state_dict()
self.xcep.load_state_dict(state_dict, False)
FLAGS = tf.flags.FLAGS
tf.flags.DEFINE_integer("num_training_iterations", 2000,
"Number of iterations to train for.")
tf.flags.DEFINE_integer("report_interval", 100,
"Iterations between reports (samples, valid loss).")
tf.flags.DEFINE_integer("batch_size", 100, "Batch size for training.")
tf.flags.DEFINE_integer("output_size", 17, "Size of output layer.")
tf.flags.DEFINE_float("weight_decay_rate", 1.e-4, "Rate for Weight Decay.")
tf.flags.DEFINE_float("train_ratio", 0.8,
"Ratio of train data in the all data.")
tf.flags.DEFINE_float("init_lr", 1.e-3, "Initial learning rate.")
tf.flags.DEFINE_integer("decay_interval", 500, "lr decay interval.")
tf.flags.DEFINE_float("decay_rate", 0.5, "lr decay rate.")
# Xceptionモジュール
xception = Xception(FLAGS.output_size, name='Xception')
image_dir_path = 'jpg'
filelist = list(filter(lambda z: z[-4:] == '.jpg', os.listdir(image_dir_path)))
filelist = np.asarray([os.path.join(image_dir_path, f) for f in filelist])
idx = np.arange(len(filelist))
np.random.shuffle(idx)
border = int(len(filelist) * FLAGS.train_ratio)
# Flower data set モジュール
dataset_train = FlowerDataSet(file_list=filelist[:border],
image_size=(149, 149),
batch=FLAGS.batch_size,
name='Flower_dataset_train')
dataset_test = FlowerDataSet(file_list=filelist[border:],
image_size=(149, 149),
import io
import json
import dlib
import torch
import base64
from io import BufferedReader, BytesIO
from skimage import io, color
import numpy as np
from PIL import Image
from flask import Flask, jsonify, request
from werkzeug.utils import secure_filename
from xception import Xception
app = Flask(__name__)
device = torch.device('cpu')
model = Xception()
ckpt_dir = 'log_path/Xception_trained_model.pth'
checkpoint = torch.load(ckpt_dir, map_location=device)
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()
message = ''
def crop_image(file):
detector_ori = dlib.get_frontal_face_detector()
# open the image file
try:
img = io.imread(file)
except Exception as e:
message = "While processing, " + str(e)
return message
data_format='channels_last', preprocessing_function=preprocess_input)
train_generator = data_generator.flow_from_directory(os.path.join(
data_dir, 'teacher_no_resizing'),
target_size=(299, 299),
batch_size=64)
val_generator = data_generator_val.flow_from_directory(os.path.join(
data_dir, 'val_no_resizing'),
shuffle=False,
target_size=(299, 299),
batch_size=64)
# # Model
model = Xception(weight_decay=1e-5)
model.count_params()
# add entropy to the usual logloss (it is for regularization),
# "Regularizing Neural Networks by Penalizing Confident Output Distributions",
# https://arxiv.org/abs/1701.06548
# it reduces overfitting a little bit
def loss(y_true, y_pred):
entropy = -K.mean(K.sum(y_pred * K.log(y_pred), 1))
beta = 0.1
return logloss(y_true, y_pred) - beta * entropy
model.compile(
# optimizer=optimizers.SGD(lr=1e-2, momentum=0.9, nesterov=True),
return gray_image
class DeepfakeTest():
def __init__(self, model, ckpt_dir):
self.transform = ToTensor()
self.checkpoint = torch.load(ckpt_dir, map_location=device)
self.model = model
self.model.load_state_dict(self.checkpoint['model_state_dict'])
# Model on cuda
if torch.cuda.is_available():
self.model = model.cuda().eval()
def test_im(self, im_dir):
im = self.transform(io.imread(im_dir))
with torch.no_grad():
input_image = im.cpu().float()
# compute output
output = self.model(input_image).cpu().numpy()
a = output.tolist()
return a
if __name__ == '__main__':
device = torch.device('cpu')
tester = DeepfakeTest(model=Xception(),
ckpt_dir='log_path/Xception_trained_model.pth')
imgs = ['cropped_testset/real/trump.png']
results = [tester.test_im(img) for img in imgs]
print(results)
type=str,
default="./data",
help='path where the dataset is saved')
parser.add_argument('--ckpt_path',
type=str,
default="./checkpoint",
help='path where the checkpoint to be saved')
parser.add_argument('--device_id',
type=int,
default=0,
help='device id of GPU. (Default: 0)')
args = parser.parse_args()
args.local_rank = 0
args.world_size = 1
network = Xception(num_classes=cfg.num_classes)
# network = nn.DataParallel(network)
network = network.cuda()
criterion = nn.CrossEntropyLoss()
# optimizer = optim.RMSprop(network.parameters(),
# lr=cfg.lr_init,
# eps=cfg.rmsprop_epsilon,
# momentum=cfg.rmsprop_momentum,
# alpha=cfg.rmsprop_decay)
optimizer = optim.SGD(network.parameters(),
lr=cfg.lr_init,
momentum=cfg.SGD_momentum)
# prepare data
# dataloader = create_dataset_pytorch(args.data_path + "/train")
pipe = HybridTrainPipe(batch_size=cfg.batch_size,
num_threads=cfg.n_workers,
print(len(images), 'images')
return images
def chunk(l, n):
for i in xrange(0, len(l), n):
yield l[i:i + n]
input_dir = sys.argv[1]
out_fn = sys.argv[2]
images = list_images(input_dir)
out_file = open(out_fn, 'w')
imodel = InceptionResNetV2(weights='imagenet')
xmodel = Xception(weights='imagenet')
rmodel = ResNet50(weights='imagenet')
vmodel = VGG19(weights='imagenet')
for fs in chunk(images, 100):
xs299 = []
xs224 = []
for f in fs:
img_path = join(input_dir, f)
img = image.load_img(img_path, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = Inc_preprocess_input(x)
xs299.append(x[0, :, :])