追求大数据（译文）

原文地址：https://www.codeproject.com/Articles/1182898/Go-for-Big-Data-2

原文作者：Intel Corporation

译文由本站 robot-v1.0 翻译

前言

With Intel DAAL, cgo, and SWIG we were able to integrate optimized Cholesky decomposition right in our Go programs.

借助Intel DAAL,cgo和SWIG,我们能够在Go程序中集成优化的Cholesky分解.

使用具有Go 编程语言的英特尔®数据分析加速库(英特尔®DAAL)来进行批处理,在线和分布式处理(Using Intel® Data Analytics Acceleration Library (Intel® DAAL) with the Go programming language to enable batch, online, and distributed processing)

最热门的现代基础设施项目由(The hottest modern infrastructure projects are powered by) 走(Go) , 包含(**, including) Kubernetes(Kubernetes) ,(**,) 码头工人(Docker) ,(**,) 领事(Consul) ,(**,) 等(etcd) , 还有很多.去变成一个(**, and many more. Go is turning into a)**去(go to)**开发人员,Web服务器和微服务的语言.它易于学习,易于部署,快速,并且为开发人员提供了很多工具.(language for devops, web servers, and microservices. It is easy to learn, easy to deploy, fast, and has a great set of tools for developers.)

但是,随着企业变得越来越以数据为驱动力,需要在公司基础架构的各个级别(包括Go发挥作用的那些级别)集成计算密集型算法.因此,自然会问我们如何将机器学习,分布式数据转换和在线数据分析之类的东西集成到我们蓬勃发展的基于Go的系统中.(But as businesses become more data driven, there is a need to integrate computationally intensive algorithms at every level of a company’s infrastructure, including those levels where Go is playing a role. Thus, it’s natural to ask how we might integrate things like machine learning, distributed data transformation, and online data analysis into our blossoming Go-based systems.)

在Go中提供强大,高性能和可扩展的数据处理的一种途径是利用(One route to providing robust, performant, and scalable data processing within Go is to utilize the) 英特尔®数据分析加速库(Intel® Data Analytics Acceleration Library) (Intel®DAAL)在我们的Go程序中.这个库已经为许多有用的任务提供了批处理,在线和分布式算法:((Intel® DAAL) within our Go programs. This library already provides batch, online, and distributed algorithms for a host of useful tasks:)

因为Go提供了一种与C/C ++进行交互的好方法,所以我们可以将此功能引入到Go程序中而不会带来太多麻烦.这样,我们可以立即利用英特尔针对这些库的架构进行的优化.如图所示(Because Go provides a nice way to interface with C/C++, we can pull this functionality into our Go programs without too much trouble. In doing so, we can take advantage of Intel’s optimizations of these libraries for their architectures right out of the box. As shown) 这里(here) ,对于某些操作(例如主成分分析),英特尔DAAL的运行速度可比Spark 和MLlib 快7倍.哇!我想说的时候到了,我们应该探索如何使用这种功能升级Go应用程序.(, Intel DAAL can be up to seven times faster than Spark plus MLlib* for certain operations, like principal component analysis. Woah! I would say it’s time we explore how to level up our Go applications with that sort of power.*)

安装英特尔®DAAL(Installing Intel® DAAL)

英特尔DAAL是(Intel DAAL is) 可作为开源(available as open source) 可以通过以下方式安装(and can be installed by following) 这些指示(these instructions) .在我的Linux 机器上,这很简单:(. On my Linux* machine this was as simple as:*)

• 下载源代码.(Downloading the source code.)
• 运行安装脚本.(Running the install script.)
• 设置必要的环境变量(也可以使用提供的shell脚本来完成).(Setting up the necessary environmental variables (which can also be done with a provided shell script).) 在尝试将Intel DAAL集成到任何Go程序之前,最好确保一切正常.您可以按照以下指南中的各种入门指南进行操作(Before trying to integrate Intel DAAL into any Go program, it’s a good idea to make sure that everything works normally. You can do this by following the various getting started guides in the) 英特尔DAAL文档(Intel DAAL docs) .具体来说,这些入门指南提供了一个示例英特尔DAAL应用程序,用于(. Specifically, these getting started guides provide an example Intel DAAL application for) 胆固醇分解(Cholesky decomposition) 我们将在下面的Go中重新创建. Cholesky分解的原始C ++示例如下所示:(that we will be recreating in Go, below. The raw C++ example of Cholesky decomposition looks like this:)

/*******************************************************************************
!  Copyright(C) 2014-2017 Intel Corporation. All Rights Reserved.
!
!  The source code, information and material ("Material") contained herein is
!  owned by Intel Corporation or its suppliers or licensors, and title to such
!  Material remains with Intel Corporation or its suppliers or licensors. The
!  Material contains proprietary information of Intel or its suppliers and
!  licensors. The Material is protected by worldwide copyright laws and treaty
!  provisions. No part of the Material may be used, copied, reproduced,
!  modified, published, uploaded, posted, transmitted, distributed or disclosed
!  in any way without Intel's prior express written permission. No license
!  under any patent, copyright or other intellectual property rights in the
!  Material is granted to or conferred upon you, either expressly, by
!  implication, inducement, estoppel or otherwise. Any license under such
!  intellectual property rights must be express and approved by Intel in
!  writing.
!
!  *Third Party trademarks are the property of their respective owners.
!
!  Unless otherwise agreed by Intel in writing, you may not remove or alter
!  this notice or any other notice embedded in Materials by Intel or Intel's
!  suppliers or licensors in any way.
!
!*******************************************************************************
!  Content:
!    Cholesky decomposition sample program.
!******************************************************************************/

#include "daal.h"
#include <iostream>

using namespace daal;
using namespace daal::algorithms;
using namespace daal::data_management;
using namespace daal::services;

const size_t dimension = 3;
double inputArray[dimension *dimension] =
{
    1.0, 2.0, 4.0,
    2.0, 13.0, 23.0,
    4.0, 23.0, 77.0
};

int main(int argc, char *argv[])
{
    /* Create input numeric table from array */
    SharedPtr<NumericTable> inputData = SharedPtr<NumericTable>(new Matrix<double>(dimension, dimension, inputArray));

    /* Create the algorithm object for computation of the Cholesky decomposition using the default method */
    cholesky::Batch<> algorithm;

    /* Set input for the algorithm */
    algorithm.input.set(cholesky::data, inputData);

    /* Compute Cholesky decomposition */
    algorithm.compute();

    /* Get pointer to Cholesky factor */
    SharedPtr<Matrix<double> > factor =
        staticPointerCast<Matrix<double>, NumericTable>(algorithm.getResult()->get(cholesky::choleskyFactor));

    /* Print the first element of the Cholesky factor */
    std::cout << "The first element of the Cholesky factor: " << (*factor)[0][0];

    return 0;
}

尝试编译并运行此程序以确保您的Intel DAAL安装成功.它还将带您领略我们在Go中的工作.英特尔DAAL安装的任何问题可以在(Try compiling and running this to make sure your Intel DAAL installation has succeeded. It will also give you a taste of what we will be doing in Go. Any questions or issues with the Intel DAAL installation can be discussed in the) 英特尔DAAL论坛(Intel DAAL forum) (当我开始学习Intel DAAL时,这对我来说是一个很好的资源).((which was a great resource for me while I was getting spun up with Intel DAAL).)

在Go中使用Intel DAAL(Using Intel DAAL in Go)

从Go中使用英特尔DAAL时,我们有两种选择:(When utilizing Intel DAAL from within Go, we have a couple of options:)

• 通过包装函数直接从Go程序中调用Intel DAAL.(Directly calling Intel DAAL from your Go program via a wrapper function.)
• 创建包含特定英特尔DAAL功能的可重用库.(Creating a reusable library that wraps specific Intel DAAL functionality.) 我将在下面演示这两个选项,并且可以找到所有使用的代码(I will demonstrate both of these options below, and all of the code used can be found) 这里(here) .这只是一个示例,最终,将更多的Go再加上Intel DAAL示例添加到此存储库将是很棒的.在进行实验时,请提交您的请求请求.我很高兴看到您的创造!(. This is just one example, and, eventually, it would be great to add more Go plus Intel DAAL examples to this repository. As you experiment, please submit your Pull Requests. I’m excited to see what you create!)

如果您不熟悉Go,请先熟悉一下自己,然后再继续本教程.实际上,您不必在本地安装Go即可开始学习.你可以上网(If you are new to Go you should familiarize yourself a bit before continuing with this tutorial. In fact, you don’t have to install Go locally to start learning. You can take the online) 围棋之旅(Tour of Go) 并使用(and use the) 去操场(Go Playground) ,然后准备就绪后,(, and then when you are ready,) 在本地安装Go(install Go locally) .(.)

直接从Go致电Intel DAAL(Calling Intel DAAL directly from Go)

Go实际上提供了一个工具,称为(Go actually provides a tool, called) go(cgo) ,这可以创建调用C代码的Go包.在这种情况下,我们将使用cgo将Go程序与Intel DAAL互操作.(, which enables the creation of Go packages that call C code. In this case, we will use cgo to interoperate our Go program with Intel DAAL.)

注意:将cgo与Go程序一起使用时需要进行多种取舍,有关这些取舍在Internet上进行了详尽的讨论(特别是,请参见(Note: there are various trade-offs for using cgo with your Go programs that are discussed at length across the Internet (in particular, see) 戴夫`切尼的讨论(Dave Cheney’s discussion) 要么(or) 本文(this article) 来自Cockroach Labs ).选择使用cgo时,您应该考虑这些费用,或者至少要意识到这些费用.在这种情况下,我们是说我们愿意与cgo进行权衡,以便利用高度优化和分布式的Intel DAAL库,这种权衡在某些数据密集型或计算密集型中可能是必要的,密集的用例.(from Cockroach Labs). When choosing to use cgo you should consider these costs, or at least be aware of them. In this case, we are saying that we are willing to work with the cgo trade-offs in order to take advantage of the highly optimized and distributed Intel DAAL library, a trade-off that is likely warranted in certain data-intensive or compute-intensive use cases.)

要将英特尔DAAL Cholesky分解功能集成到示例Go程序中,我们将需要创建一个如下所示的目录结构(在我们的(To integrate the Intel DAAL Cholesky decomposition functionality in a sample Go program, we will need to create a directory structure that looks like this (in our*) $GOPATH*)$ GOPATH( ):():)

cholesky`
├── cholesky.go`
├── cholesky.hxx`
└── cholesky.cxx`

的(The)**cholesky.go(cholesky.go)**文件是我们的Go程序,它将利用Intel DAAL Cholesky分解功能.的(file is our Go program that will utilize the Intel DAAL Cholesky decomposition functionality. The)**cholesky.cxx(cholesky.cxx)**和(and)**cholesky.hxx(cholesky.hxx)**文件是包含Intel DAAL的C ++定义/声明文件,它们将向cgo发出信号,告知我们要包装的Intel DAAL功能.让我们来看看这些.(files are C++ definition/declaration files that include Intel DAAL and will signal to cgo what Intel DAAL functionality we are going to wrap. Let’s take a look at each of these.)

首先,让我们看一下(First, let’s take a look at the) *.cxx 文件:(file:)

#include "cholesky.hxx"
#include "daal.h"
#include <iostream>

using namespace daal;
using namespace daal::algorithms;
using namespace daal::data_management;
using namespace daal::services;

int choleskyDecompose(int dimension, double inputArray[]) {

    /* Create input numeric table from array */
    SharedPtr<NumericTable> inputData = SharedPtr<NumericTable>(new Matrix<double>(dimension, dimension, inputArray));

    /* Create the algorithm object for computation of the Cholesky decomposition using the default method */
    cholesky::Batch<> algorithm;

    /* Set input for the algorithm */
    algorithm.input.set(cholesky::data, inputData);

    /* Compute Cholesky decomposition */
    algorithm.compute();

    /* Get pointer to Cholesky factor */
    SharedPtr<Matrix<double> > factor =
        staticPointerCast<Matrix<double>, NumericTable>(algorithm.getResult()->get(cholesky::choleskyFactor));

    /* Return the first element of the Cholesky factor */
    return (*factor)[0][0];
}

和(and the)*** .hxx(**.hxx*)**文件:(*file:*)

#ifndef CHOLESKY_H
#define CHOLESKY_H

// __cplusplus gets defined when a C++ compiler processes the file.
// extern "C" is needed so the C++ compiler exports the symbols w/out name issues.
#ifdef __cplusplus
extern "C" {
#endif

int choleskyDecompose(int dimension, double inputArray[]);

#ifdef __cplusplus
}
#endif

#endif

这些文件在C ++中定义了choleskyDecompose包装函数,该函数利用Intel DAAL Cholesky分解功能来计算输入矩阵的Cholesky分解并输出Cholesky因子的第一个元素(类似于Intel DAAL入门指南中所示).注意,在这种情况下,我们的输入是在一个数组中,矩阵的长度为矩阵尺寸(即3 x 3的矩阵对应于长度为9的输入数组).我们需要包括(These files define a choleskyDecompose wrapper function in C++ that utilizes the Intel DAAL Cholesky decomposition functionality to compute the Cholesky decomposition of an input matrix and output the first element of the Cholesky factor (similar to what is shown in the Intel DAAL getting started guides). Note, in this case, our input is in an array with a length of the matrix dimension (that is, a 3 x 3 matrix would correspond to an input array of length 9). We need to include) extern "C" 在我们的(in our)*** .hxx(**.hxx*)**文件.这将使cgo调用的C ++编译器知道我们需要导出在C ++文件中定义的相关名称.(*file. This will let the C++ compiler that cgo calls know that we need to export relevant names defined in our C++ files.*)

一旦我们在我们的Cholesky分解包装函数中定义了(Once we have the Cholesky decomposition wrapper function defined in our)*** .cxx(**.cxx*)**和(*and*)*** .hxx(**.hxx*)**文件,我们可以直接从Go中调用该函数.(*files, we can call that function directly from Go.*)**cholesky.go(*cholesky.go*)**看起来像:(*looks like:*)

package main

// #cgo CXXFLAGS: -I$DAALINCLUDE
// #cgo LDFLAGS: -L$DAALLIB -ldaal_core -ldaal_sequential -lpthread -lm
// #include "cholesky.hxx"
import "C"

import (
	"fmt"
	"unsafe"
)

func main() {

	// Define the input matrix as an array.
	inputArray := [9]float64{
		1.0, 2.0, 4.0,
		2.0, 13.0, 23.0,
		4.0, 23.0, 77.0,
	}

	// Get the first Cholesky decomposition factor.
	data := (*C.double)(unsafe.Pointer(&inputArray[0]))
	factor := C.choleskyDecompose(3, data)

	// Output the first Cholesky dcomposition factor to stdout.
	fmt.Printf("The first Cholesky decomp. factor is: %d\n", factor)
}

让我们逐步逐步了解发生的情况.首先,我们需要告诉Go我们在编译程序时要使用cgo,并且要使用某些标志进行编译:(Let’s walk through this step by step to understand what is happening. First, we need to tell Go that we want to utilize cgo when we compile our program, and we want to compile with certain flags:)

// #cgo CXXFLAGS: -I$DAALINCLUDE
// #cgo LDFLAGS: -L$DAALLIB -ldaal_core -ldaal_sequential -lpthread -lm
// #include "cholesky.hxx"
import "C"

要使用cgo,我们需要(To use cgo, we need to) import "C" ,这是一个伪包,告诉Go我们正在使用cgo.如果在" C"的导入后紧跟注释,则在编译软件包的C ++部分时,将被称为前导的注释用作标头.(, which is a pseudo-package telling Go that we are using cgo. If the import of “C” is immediately preceded by a comment, that comment which is called the preamble is used as a header when compiling the C++ parts of the package.)

CXXFLAGS和LDFLAGS允许我们指定希望cgo在编译期间使用的编译和链接标志,并且可以通过以下方式包含C ++函数:(CXXFLAGS and LDFLAGS allow us to specify the compile and linking flags that we want cgo to use during compilation, and we can include our C++ function via) // #include "cholesky.hxx" .我将Linux与gcc一起使用来编译此示例,因此这些标志已在上面反映出来.但是,您可以按照(. I used Linux with gcc to compile this example, so those flags are reflected above. However, you can follow) 本指南(this guide) 确定如何将应用程序链接到英特尔DAAL.(to determine how you should link your application to Intel DAAL.)

之后,我们可以像编写任何其他程序一样编写Go代码,并以(After that, we can write our Go code just as we would with any other program, and access our wrapped function as) C.choleskyDecompose() :(:)

// Define the input matrix as an array.
inputArray := [9]float64{
	1.0, 2.0, 4.0,
	2.0, 13.0, 23.0,
	4.0, 23.0, 77.0,
}

// Get the first Cholesky decomposition factor.
data := (*C.double)(unsafe.Pointer(&inputArray[0]))
factor := C.choleskyDecompose(3, data)

// Output the first Cholesky dcomposition factor to stdout.
fmt.Printf("The first Cholesky decomp. factor is: %d\n", factor)

这里的一个独特之处(使用cgo唯一)是我们需要将float64 slice的第一个元素的指针转换为(One peculiarity here (unique to using cgo) is that we need to convert the pointer to the first element of our float64 slice to an)**不安全的(unsafe)**指针,然后可以将其显式转换为(pointer, which can then be explicitly converted to a) *C.double (与C ++兼容)我们的指针((compatible with C++) pointer for our) choleskyDecompose 功能.顾名思义,不安全的程序包使我们能够绕过Go程序的类型安全.(function. The unsafe package, as the name implies, allows us to step around the type safety of Go programs.)

太好了!现在,我们有一个Go程序,称为我们的Intel DAAL Cholesky分解.现在,我们来构建并运行该程序.我们可以照常做(Ok, great! Now we have a Go program that called our Intel DAAL Cholesky decomposition. Now let’s build and run this program. We can do that as usual with) go build :(:)

$ ls
cholesky.cxx  cholesky.go  cholesky.hxx
$ go build
$ ls
cholesky  cholesky.cxx  cholesky.go  cholesky.hxx
$ ./cholesky 
The first Cholesky decomp. factor is: 1
$

然后我们得到了预期的输出!实际上,第一个Cholesky分解因子是1.我们已经直接从Go!成功地利用了Intel DAAL的功能!但是,我们的Go程序确实看起来有点不安全和C位.同样,这是一次性解决方案.现在,让我们将此功能烹饪到可导入的可重复使用的Go程序包中,就像其他任何Go程序包一样.(and we get the expected output! Indeed, the first Cholesky decomposition factor is 1. We have successfully tapped into the power of Intel DAAL directly from Go! However, our Go program does look a little peculiar with the unsafe and C bits. Also, this is kind of a one-time solution. Now, let’s cook this functionality into a reusable Go package that we can import, just like any other Go package.)

使用英特尔DAAL创建可重用的Go软件包(Creating a reusable Go package with Intel DAAL)

要创建包含英特尔DAAL功能的Go程序包,我们将使用一个名为(To create a Go package that wraps Intel DAAL functionality, we are going to use a tool called) SWIG (SWIG) .除了cgo,Go还知道如何在构建时调用SWIG来编译包装了C/C ++功能的Go软件包.要启用这种构建,我们需要创建一个目录结构,如下所示:(. In addition to cgo, Go knows how to call SWIG at build time to compile Go packages that wrap C/C++ functionality. To enable this sort of build, we need to create a directory structure that looks like:)

choleskylib
├── cholesky.go
├── cholesky.hxx
├── cholesky.cxx
└── cholesky.swigcxx

我们的(Our)*** .cxx(**.cxx*)**和(*and*)*** .hxx(**.hxx*)**包装文件可以保持不变.但是,我们现在需要添加一个(*wrapper files can stay the same. However, we now need to add a*)*** .swigcxx(**.swigcxx*)**文件.该文件如下所示:(*file. This file looks like:*)

%{
#include "cholesky.hxx"
%}

%include "cholesky.hxx"

这指示SWIG工具为我们的Cholesky函数生成包装代码,从而使我们可以将其用作Go包.(This instructs the SWIG tool to generate wrapping code for our Cholesky function, which allows us to use it as a Go package.)

另外,既然我们正在创建可重用的Go程序包(而不是独立的Go应用程序),(Also, now that we are creating a reusable Go package (not a standalone Go application), the) *.go 文件不需要包含包主体或函数主体.相反,它只需要定义我们的包名称.在这种情况下,我们称之为(file doesn’t need to include a package main or function main. Rather, it simply needs to define our package name. In this case, let’s call it) cholesky ,这意味着(, which would mean that)**cholesky.go(cholesky.go)**看起来像:(looks like:)

package cholesky

// #cgo CXXFLAGS: -I$DAALINCLUDE
// #cgo LDFLAGS: -L$DAALLIB -ldaal_core -ldaal_sequential -lpthread -lm
import "C"

(再次提供标题标志.)((Again providing the header flags.))

现在我们可以在本地构建和安装我们的软件包:(Now we can build and install our package locally:)

$ ls
cholesky.cxx  cholesky.go  cholesky.hxx  cholesky.swigcxx
$ go install
$

这将构建Go程序利用此包时调用的所有必要二进制文件和库.可以看到我们有一个(This builds all of the necessary binaries and libraries that are called when a Go program utilizes this package. Go can see that we have a)*** .swigcxx(**.swigcxx*)**文件放在我们的目录中,因此它将自动使用SWIG生成我们的程序包.(*file in our directory and, as a result, it will automatically use SWIG to build our package.*)

太棒了我们现在有一个使用Intel DAAL的Go软件包.让我们看看如何导入和使用该软件包:(Awesome; we now have a Go package that uses Intel DAAL. Let’s see how we would import and use the package:)

package main

import (
	"fmt"

	"github.com/dwhitena/daal-go/choleskylib"
)

func main() {

	// Define the input matrix as an array.
	inputArray := [9]float64{
		1.0, 2.0, 4.0,
		2.0, 13.0, 23.0,
		4.0, 23.0, 77.0,
	}

	// Get the first Cholesky decomposition factor.
	factor := cholesky.CholeskyDecompose(3, &inputArray[0])

	// Output the first Cholesky dcomposition factor to stdout.
	fmt.Printf("The first Cholesky decomp. factor is: %d\n", factor)
}

真好!与我们直接包装Intel DAAL相比,这看起来要干净得多.我们可以像其他Go包一样导入Cholesky包,然后将包装函数调用为(Nice! This looks a lot cleaner as compared to our direct wrapping of Intel DAAL. We can import the Cholesky package, similar to any other Go package, and call our wrapped function as) cholesky.CholeskyDecompose(...) .此外,SWIG还照顾了所有(. Also, SWIG has taken care of all that)**不安全的(unsafe)**给我们的东西.现在我们可以将原始float64 slice的第一个元素的地址传递给(stuff for us. Now we can just pass the address of the first element of our original float64 slice to) cholesky.CholeskyDecompose(...) .(.)

类似于任何其他Go程序,都可以使用以下程序进行编译和运行(Similar to any other Go program, this can be compiled and run with) go build :(:)

$ ls
main.go
$ go build
$ ls
example  main.go
$ ./example 
The first Cholesky decomp. factor is: 1$

好极了!正确答案.现在,我们可以在需要Cholesky分解的另一个其他Go程序中使用此程序包.(Yay! The correct answer. We can now utilize this package in another other Go program where we need Cholesky decomposition.)

结论/资源(Conclusions/Resources)

借助Intel DAAL,cgo和SWIG,我们能够在Go程序中集成优化的Cholesky分解.但是,这些技术不仅限于Cholesky分解.您可以创建Go程序和程序包,这些程序和程序包以相同的方式利用任何Intel DAAL实现的算法.这意味着您可以在Go应用程序中实现批处理,联机和分布式神经网络,群集,增强,协作过滤等功能.(With Intel DAAL, cgo, and SWIG we were able to integrate optimized Cholesky decomposition right in our Go programs. However, these techniques aren’t limited to Cholesky decomposition. You could create Go programs and packages that utilize any of the Intel DAAL implemented algorithms the same way. That means you can implement batch, online, and distributed neural networks, clustering, boostings, collaborative filtering, and much more right there in your Go applications.)

可以找到上面使用的所有代码(All of the code used above can be found) 这里(here) .(.)

Go数据资源:(Go data resources:)

• 加入(Join) 松懈的地鼠(Gophers on Slack) 然后与#data-science频道中的其他人交谈,使用Go进行大数据,数据分析,机器学习等.(and talk to a bunch of other people in the #data-science channel doing big data, data analysis, machine learning, and so on with Go.)

• 看看(Check out the) GopherData组织(GopherData organization) ,它将Go数据管理,处理,分析,机器学习和可视化工具的用户和开发人员聚集在一起.(, which is bringing together users and developers of Go data management, processing, analytics, machine learning, and visualization tools.)

• 跟随(Follow) Twitter上的GopherData(GopherData on Twitter) .(.)

• 浏览(并有助于)(Look through (and contribute to) the) 越来越多的Go数据相关工具(growing list of Go data-related tools) .(.) 英特尔DAAL资源:(Intel DAAL resources:)

• 看看(Check out the) 英特尔DAAL文档(Intel DAAL docs) .(.)

• 利用(Take advantage of) 在线培训(online training) .(.)

• 参加(Participate in the) 英特尔DAAL论坛(Intel DAAL forum) .(.)

关于作者(About the Author)

Daniel(@dwhitena)是一名博士学位.与Pachyderm(@pachydermIO)合作的训练有素的数据科学家. Daniel开发了创新的分布式数据管道,其中包括预测模型,数据可视化,统计分析等.他曾在世界各地的会议(ODSC,Spark Summit,Datapalooza,DevFest Siberia,GopherCon等)上发表演讲,与Ardan Labs(@ardanlabs)教授数据科学/工程技术,为Jupyter维护Go内核,并积极帮助组织对各种开源数据科学项目的贡献.(Daniel (@dwhitena) is a Ph.D. trained data scientist working with Pachyderm (@pachydermIO). Daniel develops innovative, distributed data pipelines which include predictive models, data visualizations, statistical analyses, and more. He has spoken at conferences around the world (ODSC, Spark Summit, Datapalooza, DevFest Siberia, GopherCon, and more), teaches data science/engineering with Ardan Labs (@ardanlabs), maintains the Go kernel for Jupyter, and is actively helping to organize contributions to various open source data science projects.)

许可

本文以及所有相关的源代码和文件均已获得The Code Project Open License (CPOL)的许可。