Java调用Python深度学习模型完成AI输入输出

Java调用Python深度学习模型完成AI输入输出

对象：DeepFaceLab

在Java应用中使用Python训练的算法模型

  • Java代码下载相应jar包（Jython）直接调用Python代码。这样做，Java应用太过于依赖Python环境。也可以将Python代码打包为jar包，然后使用Java代码调用，但很多第三方库并不能实现打包成jar包。
  • Java代码通过操作系统命令行调用，Java的ProcessBuilder API可以直接调用Python脚本运行。
  • 将Python训练的模型参数保存到文本中，使用java代码重现模型的预测算法。这种，工作量很大，而且出现bug的几率也大大增加。最重要的是，很多深度学习的框架就没法使用了。
  • 使用Python进程运行深度学习中的训练模型，在Java应用程序中调用Python进程提供的服务。Python编写的程序毕竟在Python环境中执行最有效率。而且Python应用和Java应用可以运行在不同服务器上，通过进程的远程访问调用。
  • 使用 Runtime.getRuntime () 执行Python脚本，可输入输出参数。
  • Java调用Shell方式本机运行，到资源管理器输入输出。
  • 将机器学习模型保存为 pmml 文件，然后 java 调用 pmml 文件。这种方法是网上最常见的方法，进行上线部署的时候，不会依赖于 python 环境。但不是所有的机器学习模型都可以保存为PMML文件。
  • Python REST API，把 Python 算法模型部署为 REST API，在 Java 代码中通过 HTTP 请求调用。

推荐

  1. 使用 Runtime.getRuntime () 执行 Python 脚本文件。Runtime.getRuntime ().exec ()方法是用来在一个单独的进程中执行一个命令或脚本的。这个方法的底层实现其实就是用的ProcessBuilder类，它可以更方便地设置子进程的属性和输入输出流。Runtime.getRuntime ().exec ()方法并不是使用socket来通信的，而是使用了操作系统提供的接口。
    一般来说，socket调用深度学习模型需要通过网络传输数据，可能会有更多的开销和不稳定性。而Runtime.getRuntime ()调用深度学习模型则是在本地执行命令或脚本，可能会有更好的性能和兼容性。但这也要看具体的场景和需求，没有一个绝对的答案。

  2. 考虑性能和效率，不建议既有Java的Web服务，又有Python的Web服务。如果这样的话，建议通过进程来实现Java程序和Python程序的通信，走Socket即可。最终实现，在 Java 应用程序中调用 Python 进程提供的服务。

  3. Python REST API，嵌套学习模型，开发Django之类的Python框架，把项目封装为 Web 应用。

Runtime.getRuntime () Python脚本

无输入参数

Python脚本文件

1
2
3
4
import numpy as np

a = np.arange(12).reshape(3,4)
print(a)

Java调用程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Process proc;
        try {
            proc = Runtime.getRuntime().exec("python /home/x/y/demo.py");// 执行py文件
            //用输入输出流来截取结果
            BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
            in.close();
            proc.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

有输入参数1

Python脚本文件

1
2
def add(a,b):
    return a + b

Java调用程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.test;

import org.python.core.PyFunction;
import org.python.core.PyInteger;
import org.python.core.PyObject;
import org.python.util.PythonInterpreter;

public class Function {

    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.execfile("/home/x/y/add.py");

        // 第一个参数为期望获得的函数（变量）的名字，第二个参数为期望返回的对象类型
        PyFunction pyFunction = interpreter.get("add", PyFunction.class);
        int a = 5, b = 10;
        // 调用函数，如果函数需要参数，在Java中必须先将参数转化为对应的“Python类型”
        PyObject pyobj = pyFunction.__call__(new PyInteger(a), new PyInteger(b));
        System.out.println("the anwser is: " + pyobj);
    }
}

有参数输入2

Python脚本文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import sys


def my_test(a:str, b:str)->int:
     print("Python函数运行：java调Python测试：")
     return int(a) + int(b)


if __name__=="__main__":
    print("Python脚本名：", sys.argv[0])

    my_arg = []
    for i in range(0, len(sys.argv)):
        my_arg.append(sys.argv[i])
    print("Java传入的参数长度为:" + str(len(my_arg)))

    result = my_test(my_arg[1], my_arg[2])
    print(result)

Java调用程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class JavaCallPythonRuntime {

       public static void main(String[] args) {
           // 需传入的参数
           String a = "1";
           String b = "2" ;
           System.out.println("Java中动态参数已经初始化,准备传参");
         
           // 设置命令行传入参
           String pythexeonpath= "/home/dell/miniconda3/python";
           String pythonscriptpath= "/home/x/y/pythondemo.py";
           String[] args1 = new String[] {pythexeonpath, pythonscriptpath, a, b};
         
           //Java数据a,b传入Python
           Process pr;
           try {
                pr = Runtime.getRuntime().exec(args1); 
                BufferedReader in = new BufferedReader(new InputStreamReader(pr.getInputStream(),"UTF-8"));
                String line;
                List<String> lines = new ArrayList<String>();
                while ((line = in.readLine()) != null) {
                    System.out.println(line);
                    lines.add(line); //把Python的print值保存了下来
                }
                in.close();
                pr.waitFor();
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println(e.getMessage());
            }
         
            System.out.println("Java调Python结束");
        }
}

中文乱码问题解决

用 Runtime.getRuntime.exec () 调用 Python 脚本时，Java 端捕获脚本有中文输出时，输出的中文可能是乱码，因为 Python 安装在 Windows 环境下的默认编码格式是 GBK。

解决方法：

在被调用的脚本的开头增加如下代码，一定要添加到其他依赖模块 import 之前。

1
2
3
4
5
import io
import sys

sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

Runtime.getRuntime () Shell脚本

简介

在 Linux 中运行 Java 程序时，需要调用一些 Shell 命令和脚本。而 Runtime.getRuntime ().exec () 方法给我们提供了这个功能，而且 Runtime.getRuntime () 给我们提供了以下几种 exec () 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Process exec(String command)
在单独的进程中执行指定的字符串命令。

Process exec(String[] cmdarray)
在单独的进程中执行指定命令和变量。

Process exec(String[] cmdarray, String[] envp)
在指定环境的独立进程中执行指定命令和变量。

Process exec(String[] cmdarray, String[] envp, File dir)
在指定环境和工作目录的独立进程中执行指定的命令和变量。

Process exec(String command, String[] envp)
在指定环境的单独进程中执行指定的字符串命令。

Process exec(String command, String[] envp, File dir)
在有指定环境和工作目录的独立进程中执行指定的字符串命令。

如果参数中如果没有 envp 参数或设为 null，表示调用命令将在当前程序执行的环境中执行；如果没有 dir 参数或设为 null，表示调用命令将在当前程序执行的目录中执行，因此调用到其他目录中的文件和脚本最好使用绝对路径。

各个参数的含义：

  • cmdarray: 包含所调用命令及其参数的数组。
  • command: 一条指定的系统命令。
  • envp: 字符串数组，其中每个元素的环境变量的设置格式为 name=value；如果子进程应该继承当前进程的环境，则该参数为 null。
  • dir: 子进程的工作目录；如果子进程应该继承当前进程的工作目录，则该参数为 null。

Demo

Shell脚本

shell 脚本运行指令为 sh **.sh args。注意，shell 脚本必须有执行权限，比如部署后 chmod -R 777 xx.sh 赋权。

1
2
3
4
5
6
7
8
9
10
11
#!/bin/sh
# 根据进程名杀死进程
echo "This is a $call"
if [ $# -lt 2 ]
then   echo "缺少参数：procedure_name和ip"   exit 1
fi
echo "Kill the $1 process"
PROCESS=`ps -ef|grep $1|grep $2|grep -v grep|grep -v PPID|awk '{ print $2}'`
for i in $PROCESS
do   echo "Kill the $1 process [ $i ]"
done

Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public static void invokeShell(){

  // 方法1 执行字符串命令（各个参数1234之间需要有空格）
  String path="sh /root/zpy/zpy.sh 1 2 3 4";

  //方法2 在单独的进程中执行指定命令和变量。 
  //第一个变量是sh命令，第二个变量是需要执行的脚本路径，从第三个变量开始是我们要传到脚本里的参数。
  String[] path = new String[]{"sh", "/root/zpy/zpy.sh", "1", "2", "3", "4"};

  try{
			Runtime runtime = Runtime.getRuntime();
			Process pro = runtime.exec(path);

			int status = pro.waitFor();
			if (status != 0)
			{
				System.out.println("Failed to call shell's command");
			}

			BufferedReader br = new BufferedReader(new InputStreamReader(pro.getInputStream()));
			StringBuffer strbr = new StringBuffer();
			String line;
			while ((line = br.readLine())!= null)
			{
				strbr.append(line).append("\n");
			}
			String result = strbr.toString();

			System.out.println(result);
	}
	catch (IOException ec)
	{
		ec.printStackTrace();
	}
	catch (InterruptedException ex){
		ex.printStackTrace();
	}
}

DeepFaceLab Shell脚本

原始脚本位置：https://github.com/nagadit/DeepFaceLab_Linux/tree/master/scripts

使用场景：提前训练模型模板，指定新的src图片，dst不改变，生成新的合成人脸。

模板为模型 + data_dst，指定输入图片，指定输出路径。

训练过程中，model的参数会改变，其他参数不改变。所以建议copy模板model到IO的model，使用IO的model进行训练，保存model以导出合成图片。图片导出完成后，删除IO的model。模板的model自始至终不改变。

环境初始化脚本 env.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#!/usr/bin/env bash

conda activate deepfacelab

DFL_PYTHON="python3.7"
# DeepFaceLab工作路径
DFL_WORKSPACE="workspace/"
# DeepFaceLab输入源路径，输出路径
DFL_IO_WORKSPACE="workspace/$1/"
# DeepFaceLab模板路径，指定模型 + data_dst
DFL_TP_WORKSPACE="workspace/$2/"

cd /home/xxx/deepfacelab/DeepFaceLab_Linux

if [ ! -d "$DFL_WORKSPACE" ]; then
    mkdir "$DFL_WORKSPACE"
fi

if [ ! -d "$DFL_TP_WORKSPACE" ]; then
    mkdir "$DFL_TP_WORKSPACE/data_dst"
    mkdir "$DFL_TP_WORKSPACE/data_dst/aligned"
    mkdir "$DFL_TP_WORKSPACE/data_dst/aligned_debug"
    mkdir "$DFL_TP_WORKSPACE/model"
fi

if [ ! -d "$DFL_IO_WORKSPACE" ]; then
    mkdir "$DFL_IO_WORKSPACE/data_src"
    mkdir "$DFL_IO_WORKSPACE/data_src/aligned"
    mkdir "$DFL_IO_WORKSPACE/data_src/aligned_debug"
fi

# 复制模板model到IO下model
if [ ! -d "$DFL_IO_WORKSPACE/model" ]; then
		cp -r $DFL_TP_WORKSPACE/model $DFL_IO_WORKSPACE
fi

DFL_ROOT="./"
DFL_SRC="./DeepFaceLab"

源素材生成目标图片 2_extract_image_from_data_src.sh

源素材为图片，图片到图片的extract

1
2
3
4
5
6
#!/usr/bin/env bash
source env.sh $1 $2

$DFL_PYTHON "$DFL_SRC/main.py" videoed extract-video \
    --input-file "$DFL_IO_WORKSPACE/data_src.*" \
    --output-dir "$DFL_IO_WORKSPACE/data_src"

强调：env.sh中的局部变量值可以传递到下文，不需要用export方式，export方式在并发场景下，变量会冲突。

注意：使用bash运行sh脚本。

提取SRC人脸关键数据 4_data_src_extract_faces_S3FD.sh

1
2
3
4
5
6
7
#!/usr/bin/env bash
source env.sh $1 $2

$DFL_PYTHON "$DFL_SRC/main.py" extract \
    --input-dir "$DFL_IO_WORKSPACE/data_src" \
    --output-dir "$DFL_IO_WORKSPACE/data_src/aligned" \
    --detector s3fd

提取data_dst-SRC人脸数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env bash
source env.sh $1 $2

$DFL_PYTHON "$DFL_SRC/main.py" videoed extract-video \
    --input-file "$DFL_TP_WORKSPACE/data_dst.*" \
    --output-dir "$DFL_TP_WORKSPACE/data_dst" \
    --fps 0

$DFL_PYTHON "$DFL_SRC/main.py" extract \
    --input-dir "$DFL_TP_WORKSPACE/data_dst" \
    --output-dir "$DFL_TP_WORKSPACE/data_dst/aligned" \
    --detector s3fd \
    --max-faces-from-image 0 \
    --output-debug

训练模型 6_train_SAEHD_no_preview.sh

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env bash
source env.sh $1 $2

$DFL_PYTHON "$DFL_SRC/main.py" train \
    --training-data-src-dir "$DFL_IO_WORKSPACE/data_src/aligned" \
    --training-data-dst-dir "$DFL_TP_WORKSPACE/data_dst/aligned" \
    --pretraining-data-dir "$DFL_SRC/pretrain_CelebA" \
    --model-dir "$DFL_IO_WORKSPACE/model" \
    --model SAEHD \
    --no-preview

合成输出 7_merge_SAEHD.sh

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env bash
source env.sh $1 $2

$DFL_PYTHON "$DFL_SRC/main.py" merge \
    --input-dir "$DFL_TP_WORKSPACE/data_dst" \
    --output-dir "$DFL_IO_WORKSPACE/data_dst/merged" \
    --output-mask-dir "$DFL_IO_WORKSPACE/data_dst/merged_mask" \
    --aligned-dir "$DFL_TP_WORKSPACE/data_dst/aligned" \
    --model-dir "$DFL_IO_WORKSPACE/model" \
    --model SAEHD

合并全过程脚本 env_extract_faces_train_merge.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#!/usr/bin/env bash


# env初始化
conda activate deepfacelab

DFL_PYTHON="python3.7"
# DeepFaceLab工作路径
DFL_WORKSPACE="workspace"
# DeepFaceLab输入源路径，输出路径
DFL_IO_WORKSPACE="workspace/$1"
# DeepFaceLab模板路径，指定模型 + data_dst
DFL_TP_WORKSPACE="workspace/$2"

cd /root/deepfacelab/DeepFaceLab_Linux

if [ ! -d "$DFL_WORKSPACE" ]; then
    mkdir "$DFL_WORKSPACE"
fi

if [ ! -d "$DFL_TP_WORKSPACE" ]; then
    mkdir -p "$DFL_TP_WORKSPACE/data_dst"
    mkdir -p "$DFL_TP_WORKSPACE/data_dst/aligned"
    mkdir -p "$DFL_TP_WORKSPACE/data_dst/aligned_debug"
    mkdir -p "$DFL_TP_WORKSPACE/model"
fi

if [ ! -d "$DFL_IO_WORKSPACE" ]; then
    mkdir -p "$DFL_IO_WORKSPACE/data_src"
    mkdir -p "$DFL_IO_WORKSPACE/data_src/aligned"
    mkdir -p "$DFL_IO_WORKSPACE/data_src/aligned_debug"
fi

# 复制模板model到IO下model
if [ ! -d "$DFL_IO_WORKSPACE/model" ]; then
		cp -r $DFL_TP_WORKSPACE/model $DFL_IO_WORKSPACE
fi

DFL_ROOT="./"
DFL_SRC="./DeepFaceLab"


# 数据预处理
$DFL_PYTHON "$DFL_SRC/main.py" videoed extract-video \
    --input-file "$DFL_IO_WORKSPACE/data_src.*" \
    --output-dir "$DFL_IO_WORKSPACE/data_src"


# 提取人脸特征数据
$DFL_PYTHON "$DFL_SRC/main.py" extract \
    --input-dir "$DFL_IO_WORKSPACE/data_src" \
    --output-dir "$DFL_IO_WORKSPACE/data_src/aligned" \
    --detector s3fd


# 模型快速训练
$DFL_PYTHON "$DFL_SRC/main.py" train \
    --training-data-src-dir "$DFL_IO_WORKSPACE/data_src/aligned" \
    --training-data-dst-dir "$DFL_TP_WORKSPACE/data_dst/aligned" \
    --pretraining-data-dir "$DFL_SRC/pretrain_CelebA" \
    --model-dir "$DFL_IO_WORKSPACE/model" \
    --model SAEHD \
    --no-preview


# 输出合成图
$DFL_PYTHON "$DFL_SRC/main.py" merge \
    --input-dir "$DFL_TP_WORKSPACE/data_dst" \
    --output-dir "$DFL_IO_WORKSPACE/data_dst/merged" \
    --output-mask-dir "$DFL_IO_WORKSPACE/data_dst/merged_mask" \
    --aligned-dir "$DFL_TP_WORKSPACE/data_dst/aligned" \
    --model-dir "$DFL_IO_WORKSPACE/model" \
    --model SAEHD

expect脚本 expect_deep_face_lab.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#!/usr/bin/expect
# 申明解释器expect

# 外部传递参数
set io_dir [lindex $argv 0]
set tp_dir [lindex $argv 1]

# 执行全流程脚本，$1为IO路径，$2为模板路径
spawn ./env_extract_faces_train_merge.sh $io_dir $tp_dir

# 自动化交互过程，可输入参数
# 图片预处理
expect "*Enter FPS ( ?:help ) :*"
send "\n"

expect "*Output image format ( png/jpg ?:help ) :*"
send "\n"

# 已存在 data_src/aligned，处理
set timeout 1
expect "*Press enter to continue.*"
send "\n"

# 提取人脸SRC数据
expect "*Which GPU indexes to choose? :*"
send "\n"

expect "*Face type ( f/wf/head ?:help ) :*"
send "\n"

expect "*Max number of faces from image ( ?:help ) :*"
send "\n"

expect "*Image size ( 256-2048 ?:help ) :*"
send "\n"

expect "*Jpeg quality ( 1-100 ?:help ) :*"
send "\n"

expect "*Write debug images to aligned_debug? ( y/n ) :*"
send "\n"

# 训练模型
set timeout 60
expect "*猫之汉化224df-d 4G可用 - latest*"
send "\n"

expect "*Which GPU indexes to choose? :*"
send "\n"

# 训练结束方式：根据预设的迭代次数；根据时间间隔

# 2s不按，自动加载默认参数，这种只能根据时间间隔结束训练
# 想设置迭代次数结束训练，就必须在2s内按下回车，重新设置迭代次数参数，及其他参数

# 一定时间后 Ctrl + c 结束训练
# 超时时间单位s
set timeout 80
expect "*WAIT WAIT WAIT WAIT WAIT WAIT WAIT WAIT*"
# 发送组合键的ASCII，十六进制
send "\03"

# 合成输出图
expect "*猫之汉化224df-d 4G可用 - latest*"
send "\n"

expect "*Which GPU indexes to choose? :*"
send "\n"

expect "*Use interactive merger? ( y/n ) :*"
send "n\n"

expect "*(6) raw-predict*"
send "\n"

expect "*(9) learned-prd*learned-dst*XSeg-prd*XSeg-dst*"
send "3\n"

expect "*Choose erode mask modifier ( -400..400 ) :*"
send "\n"

expect "*Choose blur mask modifier ( 0..400 ) :*"
send "300\n"

expect "*Choose motion blur power ( 0..100 ) :*"
send "\n"

expect "*Choose output face scale modifier ( -50..50 ) :*"
send "\n"

expect "*Color transfer to predicted face ( rct/lct/mkl/mkl-m/idt/idt-m/sot-m/mix-m ) :*"
send "\n"

expect "*(2) gaussian*"
send "2\n"

expect "*Choose blur/sharpen amount ( -100..100 ) :*"
send "\n"

expect "*Choose super resolution power ( 0..100 ?:help ) :*"
send "\n"

expect "*Choose image degrade by denoise power ( 0..500 ) :*"
send "\n"

expect "*Choose image degrade by bicubic rescale power ( 0..100 ) :*"
send "\n"

expect "*Degrade color power of final image ( 0..100 ) :*"
send "\n"

expect "*Number of workers? ( 1-* ?:help ) :*"
send "\n"

# expect ""
# send "\n"

# 结束
expect off

expect脚本环境安装 Ubuntu

sudo apt-get install expect

执行expect脚本

expect expect_deep_face_lab.sh xxx yyy

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>