ND4J求多元线性回归以及GPU和CPU计算性能对比

上一篇博客《梯度下降法求多元线性回归及Java实现》简单了介绍了梯度下降法，并用Java实现了一个梯度下降法求回归的例子。本篇博客，尝试用dl4j的张量运算库nd4j来实现梯度下降法求多元线性回归，并比较GPU和CPU计算的性能差异。

一、ND4J简介

ND4J是DL4J提供的张量运算库，提供了多种张量运算的封装，以下内容复杂于ND4J官网：

ND4J和ND4S是JVM的科学计算库，并为生产环境设计，亦即例程运行速度快，RAM要求低。

主要特点：

多用途多维数组对象
多平台功能，包括GPU
线性代数和信号处理功能

由于易用性上存在的缺口，Java、Scala和Clojure编程人员无法充分利用NumPy或Matlab等数据分析方面最强大的工具。Breeze等其他库则不支持多维数组或张量，而这却是深度学习和其他任务的关键。ND4J和ND4S正得到国家级实验室的使用，以完成气候建模等任务。这类任务要求完成计算密集的模拟运算。

ND4J在开源、分布式、支持GPU的库内，为JVM带来了符合直觉的、Python编程人员所用的科学计算工具。在结构上，ND4J与SLF4J相似。ND4J让生产环境下的工程师能够轻松将算法和界面移植到Java和Scala体系内的其他库内。

更详细的特性，可以去nd4j官网了解，地址：https://nd4j.org/cn

二、具体实现

1、maven配置

首先建一个maven工程，pom.xml完整配置如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>org.dl4j</groupId>
	<artifactId>linear-regression</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>linear-regression</name>
	<url>http://maven.apache.org</url>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<logback.version>1.1.7</logback.version>
		<nd4j.version>1.0.0-beta</nd4j.version>
		<!-- Change the nd4j.backend property to nd4j-cuda-8.0-platform, nd4j-cuda-9.0-platform 
			or nd4j-cuda-9.1-platform to use CUDA GPUs -->
		<!-- <nd4j.backend>nd4j-cuda-8.0-platform</nd4j.backend>  -->
		<nd4j.backend>nd4j-native-platform</nd4j.backend> 
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>org.nd4j</groupId>
			<artifactId>${nd4j.backend}</artifactId>
			<version>${nd4j.version}</version>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
</project>

说明：<nd4j.backend>nd4j-native-platform</nd4j.backend> 计算后台为CPU

也可以换为Cuda GPU计算，1.0.0 beta版支持cuda8.0、cuda9.0、cuda9.1，对应的<nd4j.backend>配置可改为nd4j-cuda-8.0-platform, nd4j-cuda-9.0-platform 或者 nd4j-cuda-9.1-platform

2、首先构建训练集，这里我们用的还是如下函数：

代码如下：

int exampleCount = 100;   
Random random = new Random();
double[] data = new double[exampleCount * 3];
double[] param = new double[exampleCount * 3];
for (int i = 0; i < exampleCount * 3; i++) {
    data[i] = random.nextDouble();
}
for (int i = 0; i < exampleCount * 3; i++) {
    param[i] = 3;
    param[++i] = 4;
    param[++i] = 5;
}
INDArray features = Nd4j.create(data, new int[] { exampleCount, 3 });
INDArray params = Nd4j.create(param, new int[] { exampleCount, 3 });
INDArray label = features.mul(params).sum(1).add(10);

mul：表示两个矩阵对应的维度相乘

sum：指定沿着某一维的方向求和，这里sum(1)表示沿着列的方向求和

add：给张量中的每一个值都加上一个标量，当然也可以是加上张量

3、批量梯度下降（BGD）实现

private static void BGD(INDArray features, INDArray label, double learningRate, double[] parameter) {
	INDArray temp=features.getColumn(0).mul(parameter[0]).add(features.getColumn(1).mul(parameter[1]))
			.add(features.getColumn(2).mul(parameter[2])).add(parameter[3]).sub(label);
	parameter[0]=parameter[0]-2*learningRate*temp.mul(features.getColumn(0)).sum(0).getDouble(0)/features.size(0);
	parameter[1]=parameter[1]-2*learningRate*temp.mul(features.getColumn(1)).sum(0).getDouble(0)/features.size(0);
	parameter[2]=parameter[2]-2*learningRate*temp.mul(features.getColumn(2)).sum(0).getDouble(0)/features.size(0);
	parameter[3]=parameter[3]-2*learningRate*temp.sum(0).getDouble(0)/features.size(0);
	INDArray functionResult=features.getColumn(0).mul(parameter[0]).add(features.getColumn(1).mul(parameter[1]))
			.add(features.getColumn(2).mul(parameter[2])).add(parameter[3]).sub(label);//用最新的参数计算总损失用
	double totalLoss=functionResult.mul(functionResult).sum(0).getDouble(0);
	System.out.println("totalLoss:"+totalLoss);
	System.out.println(parameter[0] + " " + parameter[1] + " " + parameter[2] + " " + parameter[3]);
}

4、完整代码如下，我们循环3000次，基本找出了参数。

public class LinearRegression {
 
	public static void main(String[] args) {
		int exampleCount = 100;
		double learningRate = 0.01;
		Random random = new Random();
		double[] data = new double[exampleCount * 3];
		double[] param = new double[exampleCount * 3];
		for (int i = 0; i < exampleCount * 3; i++) {
			data[i] = random.nextDouble();
		}
		for (int i = 0; i < exampleCount * 3; i++) {
			param[i] = 3;
			param[++i] = 4;
			param[++i] = 5;
		}
		INDArray features = Nd4j.create(data, new int[] { exampleCount, 3 });
		INDArray params = Nd4j.create(param, new int[] { exampleCount, 3 });
		INDArray label = features.mul(params).sum(1).add(10);
		double[] parameter = new double[] { 1.0, 1.0, 1.0, 1.0 };
		long startTime = System.currentTimeMillis();
		for (int i = 0; i < 3000; i++) {
			BGD(features, label, learningRate, parameter);
		}
		System.out.println("耗时：" + (System.currentTimeMillis() - startTime));
	}
 
	private static void BGD(INDArray features, INDArray label, double learningRate, double[] parameter) {
		INDArray temp = features.getColumn(0).mul(parameter[0]).add(features.getColumn(1).mul(parameter[1]))
				.add(features.getColumn(2).mul(parameter[2])).add(parameter[3]).sub(label);
		parameter[0] = parameter[0]
				- 2 * learningRate * temp.mul(features.getColumn(0)).sum(0).getDouble(0) / features.size(0);
		parameter[1] = parameter[1]
				- 2 * learningRate * temp.mul(features.getColumn(1)).sum(0).getDouble(0) / features.size(0);
		parameter[2] = parameter[2]
				- 2 * learningRate * temp.mul(features.getColumn(2)).sum(0).getDouble(0) / features.size(0);
		parameter[3] = parameter[3] - 2 * learningRate * temp.sum(0).getDouble(0) / features.size(0);
		INDArray functionResult = features.getColumn(0).mul(parameter[0]).add(features.getColumn(1).mul(parameter[1]))
				.add(features.getColumn(2).mul(parameter[2])).add(parameter[3]).sub(label);// 用最新的参数计算总损失用
		double totalLoss = functionResult.mul(functionResult).sum(0).getDouble(0);
		System.out.println("totalLoss:" + totalLoss);
		System.out.println(parameter[0] + " " + parameter[1] + " " + parameter[2] + " " + parameter[3]);
	}
}

5、运行结果

totalLoss:0.2690272927284241

参数：3.1580112185120623 、4.092539676684143、 5.0879424870036525、 9.820665847778292

三、GPU与CPU运行性能对比

操作系统：window10

CPU：Intel core(TM) i7-5700HQ CPU @2.70GHz

GPU：NVIDIA Geforce GTX 950M

CUDA：Cuda 8.0，V8.0.44

样本数量	CPU耗时	GPU耗时
1000	1314ms	11013ms
10000	3430ms	11608ms
100000	16544ms	17873ms
500000	78713ms	49151ms
1000000	156387ms	83001ms

GPU在矩阵运算加速有优势，在深度学习中，当参数规模和样本规模比较大的时候，选择GPU加速，计算速度会有明显的提升

快乐源于分享。

此博客乃作者原创，转载请注明出处

ND4J求多元线性回归以及GPU和CPU计算性能对比

猜你喜欢