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

时间  2019-11-13
标签 nd4j 多元 线性 回归 以及 gpu cpu 计算 性能 对比 栏目 应用数学 繁體版
原文   原文链接

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

    1、ND4J简介算法

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

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

    主要特色：数组

 

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

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

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

更详细的特性，能够去nd4j官网了解，地址：https://nd4j.org/cn分布式

2、具体实现函数

    一、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

    二、首先构建训练集，这里咱们用的仍是以下函数：

   

    代码以下：

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：给张量中的每个值都加上一个标量，固然也能够是加上张量

三、批量梯度降低（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]);
}

四、完整代码以下，咱们循环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]);
	}
}

五、运行结果

totalLoss:0.2690272927284241

参数：3.1580112185120623 、4.09253967668414三、 5.087942487003652五、 9.820665847778292

3、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加速，计算速度会有明显的提高

快乐源于分享。

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程