def convert_face(inputqueue, outputqueue, swap_model, thread_number, double_pass): from model import autoencoder_A from model import autoencoder_B from model import encoder, decoder_A, decoder_B encoder.load_weights("models/encoder.h5") decoder_A.load_weights("models/decoder_A.h5") decoder_B.load_weights("models/decoder_B.h5") if swap_model: autoencoder, otherautoencoder = autoencoder_A, autoencoder_B else: autoencoder, otherautoencoder = autoencoder_B, autoencoder_A while True: item = inputqueue.get() if item is None: break image, mat, sourceFace, face, framepts = item new_face_rgb, new_face_m = autoencoder.predict([face, zmask]) if double_pass: #feed the original prediction back into the network for a second round. new_face_rgb = new_face_rgb.reshape((128, 128, 3)) new_face_rgb = cv2.resize(new_face_rgb, (64, 64)) new_face_rgb = numpy.expand_dims(new_face_rgb, 0) new_face_rgb, _ = autoencoder.predict([new_face_rgb, zmask]) _, other_face_m = otherautoencoder.predict([face, zmask]) outputqueue.put((image, mat, sourceFace, new_face_rgb, new_face_m, other_face_m, framepts)) for i in range(thread_number): outputqueue.put(None)
def applymodel(vidpath,outpath,mdlpath): try: encoder.load_weights(mdlpath+r"/encoder.h5") decoder_A.load_weights(mdlpath+r"/decoder_A.h5") decoder_B.load_weights(mdlpath+r"/decoder_B.h5") print("Model succesfully loaded") except: print("error no model found") cap = cv2.VideoCapture(vidpath) width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(cap.get(cv2.CAP_PROP_FPS)) frames_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) outfilenm=outpath+r"/out.avi" writer = cv2.VideoWriter(outfilenm,cv2.VideoWriter_fourcc('M','J','P','G'), fps, (width, height)) fr=0 for i in range(frames_count): stat,frame = cap.read() #try: #print(frame.shape) #input() #cv2.imshow("hasdasdj",frame) start_time = time.time() writer.write(applyswap(frame,autoencoder_A)) print(str(fr)+"--- %s seconds ---" % (time.time() - start_time)) fr=fr+1 cap.release() writer.release()
def Train(Odir, TAdir, Mdir, ep, sv): imgsA = loadImgs(Odir) / 255.0 imgsB = loadImgs(TAdir) / 255.0 imgsA += imgsB.mean(axis=(0, 1, 2)) - imgsA.mean(axis=(0, 1, 2)) try: encoder.load_weights(Mdir + "/encoder.h5") decoder_A.load_weights(Mdir + "/decoder_A.h5") decoder_B.load_weights(Mdir + "/decoder_B.h5") print("loaded existing model") except: print("No existing model") for epoch in range(int(ep)): # get next training batch batch_size = 64 warped_A, target_A = get_training_data(imgsA, batch_size) warped_B, target_B = get_training_data(imgsB, batch_size) # train and calculate loss loss_A = autoencoder_A.train_on_batch(warped_A, target_A) loss_B = autoencoder_B.train_on_batch(warped_B, target_B) if epoch % int(sv) == 0: print("Training loss " + str(epoch) + " :") print(loss_A, loss_B) # save model every 100 steps save_model_weights(Mdir) test_A = target_A[0:14] test_B = target_B[0:14] # create image and write to disk # save our model after training has finished save_model_weights(Mdir)
def main(args): output_dir = Path(args.output_dir) encoder.load_weights(str(output_dir / "models" / "encoder.h5")) #decoder_A.load_weights( str(output_dir/ "models" / "decoder_A.h5" )) decoder_B.load_weights(str(output_dir / "models" / "decoder_B.h5")) input_dir = output_dir / "old_faces" output_dir = output_dir / "new_faces" output_dir.mkdir(parents=True, exist_ok=True) images_A = get_image_paths(str(input_dir)) for fn in images_A: print(Path(fn).name) image = cv2.imread(fn) new_image = convert_one_image(autoencoder_B, image) output_file = output_dir / Path(fn).name cv2.imwrite(str(output_file), new_image)
import uuid import logging import datetime import json import math import urllib import config from model import autoencoder_A, autoencoder_B, autoencoder_A_swift from model import encoder, decoder_A, decoder_B, decoder_A_swift, encoder_swift from keras import backend as K import redis global graph, r encoder.load_weights("models/encoder256.h5") decoder_A.load_weights("models/decoder256_A.h5") decoder_B.load_weights("models/decoder256_B.h5") encoder_swift.load_weights("models/encoder256_ENCODER.h5") decoder_A_swift.load_weights("models/decoder256_A_TAYLOR.h5") #decoder_B_swift.load_weights( "models/decoder256_B_swift.h5" ) graph = tf.get_default_graph() r = redis.Redis.from_url(config.REDIS_CONFIG['uri']) #logging.basicConfig(level=logging.DEBUG) def tensorThread(something): def url_to_image(url):
import cv2 import numpy from pathlib import Path from utils import get_image_paths from model import autoencoder_A from model import autoencoder_B from model import encoder, decoder_A, decoder_B videopath = "../../../data/faceswap/video/" modelpath = "../../../data/faceswap/" encoder.load_weights(modelpath + "models/encoder.h5") decoder_A.load_weights(modelpath + "models/decoder_A.h5") decoder_B.load_weights(modelpath + "models/decoder_B.h5") images_A = get_image_paths("../../../data/faceswap/original3/a") images_B = get_image_paths("../../../data/faceswap/original3/b") def convert_one_image(autoencoder, image): assert image.shape == (256, 256, 3) crop = slice(48, 208) face = image[crop, crop] face = cv2.resize(face, (64, 64)) face = numpy.expand_dims(face, 0) new_face = autoencoder.predict(face / 255.0)[0] new_face = numpy.clip(new_face * 255, 0, 255).astype(image.dtype) new_face = cv2.resize(new_face, (160, 160)) new_image = image.copy()
import cv2 import numpy from utils import get_image_paths, load_images, stack_images from training_data import get_training_data from model import autoencoder_A from model import autoencoder_B from model import encoder, decoder_A, decoder_B try: encoder.load_weights("/input/data/models/encoder.h5") decoder_A.load_weights("/input/data/models/decoder_A.h5") decoder_B.load_weights("/input/data/models/decoder_B.h5") except: pass def save_model_weights(): encoder.save_weights("/input/data/models/encoder.h5") decoder_A.save_weights("/input/data/models/decoder_A.h5") decoder_B.save_weights("/input/data/models/decoder_B.h5") print("save model weights") images_A = get_image_paths("/input/data/data/trump") images_B = get_image_paths("/input/data/data/cage") images_A = load_images(images_A) / 255.0 images_B = load_images(images_B) / 255.0 images_A += images_B.mean(axis=(0, 1, 2)) - images_A.mean(axis=(0, 1, 2))
import argparse import sys import cv2 import json import numpy from pathlib import Path from tqdm import tqdm sys.path.append("../lib/") from model import autoencoder_A, autoencoder_B, encoder, decoder_A, decoder_B encoder.load_weights("../models/encoder.h5") decoder_A.load_weights("../models/decoder_A.h5") decoder_B.load_weights("../models/decoder_B.h5") def convert_one_image(autoencoder, image, mat): size = 64 image_size = image.shape[1], image.shape[0] face = cv2.warpAffine(image, mat * size, (size, size)) face = numpy.expand_dims(face, 0) new_face = autoencoder.predict(face / 255.0)[0] new_face = numpy.clip(new_face * 255, 0, 255).astype(image.dtype) face_mask = numpy.zeros(new_face.shape, dtype=image.dtype) image_mask = numpy.zeros(image.shape, dtype=image.dtype) cv2.circle(face_mask, (size // 2, size // 2), int(size * 0.6), (255, 255, 255), -1) cv2.warpAffine(face_mask, mat * size, image_size, image_mask, cv2.WARP_INVERSE_MAP, cv2.BORDER_TRANSPARENT)
from keras.models import load_model from MdlTrain import * import numpy as np import cv2 from model import autoencoder_B,autoencoder_A from model import encoder, decoder_A, decoder_B image_size = 64 encoder.load_weights("nwmdlt/encoder.h5") decoder_A.load_weights("nwmdlt/decoder_A.h5") decoder_B.load_weights("nwmdlt/decoder_B.h5") imgsA=loadImgs(r"C:\Users\Q\Documents\Deepswap\Oout2")/255 imgsB=loadImgs(r"C:\Users\Q\Documents\Deepswap\TaOutT")/255 #imgsA=loadImgs(r"C:\Users\Q\Documents\Deepswap\Oout")/255.0 #imgsB=loadImgs(r"C:\Users\Q\Documents\Deepswap\TaOut")/255.0 a_faces = np.ndarray(shape=(5,128,128,3)) b_faces = np.ndarray(shape=(5,128,128,3)) ##for i in range(10): ## print(imgsA[i].shape) ## print(a_faces[i].shape) ## a_faces[i] = cv2.resize(imgsA[i], (64,64), interpolation = cv2.INTER_AREA) ## #imgsA[i]=cv2.resize(imgsA[i],(64,64)) ## #a_faces[i]=imgsA[i] ## b_faces[i] = cv2.resize(imgsB[i], (64,64), interpolation = cv2.INTER_AREA)