We are pleased to announce the inception of the Intel® Data Analytics Acceleration Library (Intel® DAAL) open source project. Intel DAAL helps to speed up big data analysis by providing highly optimized algorithmic building blocks for all stages of data analytics (preprocessing, transformation, analysis, modeling, validation, and decision making) in batch, online, and distributed processing modes of computation. The open source project is licensed under Apache License 2.0. 

Please see an overview video, blog posts, etc.: https://01.org/daal 

Features

• C++, Java, and Python APIs.
• Support Linux*, Windows*, and OS X*.
• Batch, online, and distributed processing modes. 
• Data connectors to HDFS, MySQL, CSV files, in-memory strings, as well as user defined data sources.
• Descriptive statistics algorithms: low order moments, quantiles, correlation and variance-covariance matrix, cosine distance matrix, correlation distance matrix.
• Data transformation: QR decomposition, Cholesky decomposition, SVD.
• Linear regression
• Classification algorithms: SVM, Naive Bayes, ensemble learning with boosting (AdaBoost, BrownBoost, LogitBoost), multi-class classifiers.
• Unsupervised learning: PCA, Kmeans, expectation-maximation for GMM, anomaly detection, association rules mining.
• Recommendation system: collaborative filtering based on ALS (alternating least squares).
• Convolutional neural networks.

Github 

https://github.com/01org/daal 

Online Documentation

You can find the current Intel DAAL documentation on the Intel(R) Data Analytics Acceleration Library 2017 Beta Documentation Download web page.

Tutorials

Some tutorials and code samples of how to use Intel DAAL can be found on this page. 

Hi all!

I'm using the SDCON routine to perform a convolution transformation with Fortran, and I have to admit that it has (by far) better performances that what we have been writing.

I did a simple profiling of my code to check which part is the heaviest in terms of CPU time. It turned out to be the part including the convolution calculation, essentially because I'm calling the SDCON routine 7 times each time step!

I'm wondering if a parallel (or multi-threaded) version of it exists? I'm looking for enhancing the performances of my code, and it would be really helpful.

Thank you very much for helping me.

With best regards,

Ouissem

Hello Guys,.

I am using the LAPACKE_cheev now from MKL. I have written a piece of code with this API. However, its outputs are out of my expectation. The code is attached. 

	lapack_complex_float *a = (lapack_complex_float*)malloc(sizeof(lapack_complex_float)*N*N);
	a[0].imag = 0;
	a[0].real = 0;
	a[1].imag = 1;
	a[1].real = 0;
	a[2].imag = 0;
	a[2].real = 1;
	a[3].imag = 0;
	a[3].real = 0;
	a[4].imag = 0;
	a[4].real = 0;
	a[5].imag = 0;
	a[5].real = 0;

	int matrix_order = LAPACK_ROW_MAJOR; //LAPACK_COL_MAJOR
	const char jobz = 'N';
	const char uplo = 'U';
	lapack_int n = N;
	lapack_int lda = N;
	float *w = (float*)malloc(sizeof(float)*N);

LAPACKE_cheev(matrix_order, jobz, uplo, n, a, lda, w);

	for (int i = 0; i < N; i++)
	{
		cout << w[i] << endl;
	}

I expect the outputs as follows:

[-1.414, 0, 1.414]

However, the outputs from my local machine is as follows:

[-4.31602e+008, -1, 1]

Could anybody help me with this issue?

Intel® Math Kernel Library (Intel® MKL) is a highly optimized, extensively threaded, and thread-safe library of mathematical functions for engineering, scientific, and financial applications that require maximum performance. Intel MKL 11.3 Update 3 packages are now ready for download. Intel MKL is available as part of the Intel® Parallel Studio XE and Intel® System Studio . Please visit the Intel® Math Kernel Library Product Page.

Intel® MKL 11.3 Update 3 Bug fixes

What's New in Intel MKL 11.3 Update 3

• Performance improvements for Intel Optimized MP LINPACK Benchmark on Intel® Advanced Vector Extensions 512 (Intel® AVX512) and second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
• BLAS:
  • Improved small matrix [S,D]GEMM performance on Intel AVX2, Intel AVX512 and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved threading (OpenMP) performance of xGEMMT, xHEMM, xHERK, xHER2K, xSYMM, xSYRK, xSYR2K on Intel AVX512, and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved [C,Z]GEMV, [C,Z]TRMV, and [C,Z]TRSV performance on Intel AVX2, Intel AVX512, Intel® Xeon® product family,and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
• LAPACK:
  • Updated Intel MKL LAPACK to the latest LAPACK version 3.6 specification. New features introduced in this version are:
    • SVD by Jacobi ([CZ]GESVJ) and preconditioned Jacobi ([CZ]GEJSV) algorithms
    • SVD via EVD allowing computation of a subset of singular values and vectors (?GESVDX)
    • Level 3 BLAS versions of generalized Schur (?GGES3), generalized EVD (?GGEV3), generalized SVD (?GGSVD3) and reduction to generalized upper Hessenberg form (?GGHD3)
    • Multiplication of general matrix by a unitary/orthogonal matrix possessing 2x2 structure ( [DS]ORM22/[CZ]UNM22)
  • Improved performance of LU (?GETRF) and QR(?GEQRF) on Intel AVX512 and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved check of parameters for correctness in all LAPACK routines to enhance security
• SCALAPACK:
  • Improved hybrid (MPI + OpenMP) performance of ScaLAPACK/PBLAS by increasing default block size returned by pilaenv
• SparseBlas:
  • Added examples that cover spmm and spmmd functionality
  • Improved performance of parallel mkl_sparse_d_mv for general BSR matrices on Intel AVX2
  • Parallel Direct Sparse Solver for Clusters:
    • Improved performance of solving step for small matrices (less than 10000 elements)
    • Added mkl_progress support in Parallel Direct sparse solver for Clusters and fixed mkl_progress in Intel MKL PARDISO
• Vector Mathematical Functions:
  • Improved implementation of Thread Local Storage (TLS) allocation/de-allocation, which helps with thread safety for DLLs in Windows when they are custom-made from static libraries
  • Improved the automatic threading algorithm leading to more even distribution of vectors across larger numbers of threads and improved the thread creation logic on Intel Xeon Phi, leading to improved performance on average

Contents

• File: w_mkl_11.3.3.207_online.exe

  Online Installer for Windows

• File: w_mkl_11.3.3.207.exe

  A File containing the complete product installation for Windows* (32-bit/x86-64bit development)

Intel® Math Kernel Library (Intel® MKL) is a highly optimized, extensively threaded, and thread-safe library of mathematical functions for engineering, scientific, and financial applications that require maximum performance. Intel MKL 11.3 Update 3 packages are now ready for download. Intel MKL is available as part of the Intel® Parallel Studio XE and Intel® System Studio . Please visit the Intel® Math Kernel Library Product Page.

Intel® MKL 11.3 Update 3 Bug fixes

What's New in Intel MKL 11.3 Update 3

• Performance improvements for Intel Optimized MP LINPACK Benchmark on Intel® Advanced Vector Extensions 512 (Intel® AVX512) and second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
• BLAS:
  • Improved small matrix [S,D]GEMM performance on Intel AVX2, Intel AVX512 and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved threading (OpenMP) performance of xGEMMT, xHEMM, xHERK, xHER2K, xSYMM, xSYRK, xSYR2K on Intel AVX512, and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved [C,Z]GEMV, [C,Z]TRMV, and [C,Z]TRSV performance on Intel AVX2, Intel AVX512, Intel® Xeon® product family,and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
• LAPACK:
  • Updated Intel MKL LAPACK to the latest LAPACK version 3.6 specification. New features introduced in this version are:
    • SVD by Jacobi ([CZ]GESVJ) and preconditioned Jacobi ([CZ]GEJSV) algorithms
    • SVD via EVD allowing computation of a subset of singular values and vectors (?GESVDX)
    • Level 3 BLAS versions of generalized Schur (?GGES3), generalized EVD (?GGEV3), generalized SVD (?GGSVD3) and reduction to generalized upper Hessenberg form (?GGHD3)
    • Multiplication of general matrix by a unitary/orthogonal matrix possessing 2x2 structure ( [DS]ORM22/[CZ]UNM22)
  • Improved performance of LU (?GETRF) and QR(?GEQRF) on Intel AVX512 and on second generation of Intel® Xeon Phi™ Product Family (codename Knights Landing)
  • Improved check of parameters for correctness in all LAPACK routines to enhance security
• SCALAPACK:
  • Improved hybrid (MPI + OpenMP) performance of ScaLAPACK/PBLAS by increasing default block size returned by pilaenv
• SparseBlas:
  • Added examples that cover spmm and spmmd functionality
  • Improved performance of parallel mkl_sparse_d_mv for general BSR matrices on Intel AVX2
  • Parallel Direct Sparse Solver for Clusters:
    • Improved performance of solving step for small matrices (less than 10000 elements)
    • Added mkl_progress support in Parallel Direct sparse solver for Clusters and fixed mkl_progress in Intel MKL PARDISO
• Vector Mathematical Functions:
  • Improved implementation of Thread Local Storage (TLS) allocation/de-allocation, which helps with thread safety for DLLs in Windows when they are custom-made from static libraries
  • Improved the automatic threading algorithm leading to more even distribution of vectors across larger numbers of threads and improved the thread creation logic on Intel Xeon Phi, leading to improved performance on average

Contents

• File: l_mkl_11.3.3.210_online.sh

  Online Installer for Windows

• File: l_mkl_11.3.3.210.tgz

  A File containing the complete product installation for Windows* (32-bit/x86-64bit development)

Intel® Math Kernel Library (Intel® MKL) is a highly optimized, extensively threaded, and thread-safe library of mathematical functions for engineering, scientific, and financial applications that require maximum performance. Intel MKL 11.3 Update 3 packages are now ready for download. Intel MKL is available as part of the Intel® Parallel Studio XE and Intel® System Studio . Please visit the Intel® Math Kernel Library Product Page.

Intel® MKL 11.3 Update 3 Bug fixes

New Features in MKL 11.3 Update 3

• Improved Intel Optimized MP LINPACK Benchmark performance for Clusters on Intel® Advanced Vector Extensions 512 (Intel® AVX-512) 
• BLAS:
  • Improved small matrix [S,D]GEMM performance on Intel® Advanced Vector Extensions 2 (Intel® AVX2), Intel® Xeon® product family and Intel® AVX-512
  • Improved threading (OpenMP) performance of xGEMMT, xHEMM, xHERK, xHER2K, xSYMM, xSYRK and xSYR2K on Intel® AVX-512
  • Improved [C,Z]GEMV, [C,Z]TRMV, and [C,Z]TRSV performance on Intel® AVX2, Intel® AVX512 and Intel® Xeon® product family
  • Fixed CBLAS_?GEMMT interfaces to correctly call underlying Fortran interface for row-major storage
• LAPACK:
  • Updated Intel MKL LAPACK functionality to latest Netlib version 3.6. New features introduced in this version are:
    • SVD by Jacobi ([CZ]GESVJ) and preconditioned Jacobi ([CZ]GEJSV) algorithms
    • SVD via EVD allowing computation of a subset of singular values and vectors (?GESVDX)
    • Level 3 BLAS versions of generalized Schur (?GGES3), generalized EVD (?GGEV3), generalized SVD (?GGSVD3) and reduction to generalized upper Hessenberg form (?GGHD3)
    • Multiplication of general matrix by a unitary/orthogonal matrix possessing 2x2 structure ( [DS]ORM22/[CZ]UNM22)
  • Improved performance of LU (?GETRF) and QR(?GEQRF) on Intel® AVX-512 
  • Improved check of parameters for correctness in all LAPACK routines to enhance security
• SCALAPACK:
  • Improved hybrid (MPI + OpenMP) performance of ScaLAPACK/PBLAS by increasing default block size returned by pilaenv
• SparseBlas:
  • Added examples that cover spmm and spmmd functionality
  • Improved performance of parallel mkl_sparse_d_mv for general BSR matrices on Intel® AVX2
• Parallel Direct Sparse Solver for Clusters:
  • Improved performance of solving step for small matrices (less than 10000 elements)
  • Added mkl_progress support in Parallel Direct sparse solver for Clusters and fixed mkl_progress in Intel MKL PARDISO
• Vector Mathematical Functions:
  • Improved implementation of Thread Local Storage (TLS) allocation/de-allocation, which helps with thread safety for DLLs in Windows when they are custom-made from static libraries

Check out the latest Release Notes for more updates

Contents

• File: m_mkl_online_11.3.3.170.dmg

  Online Installer for OS X*

• File: m_mkl_11.3.3.170.dmg

  A File containing the complete product installation for OS X* (32-bit/x86-64bit development)

Hi all, I'm using mpiifort to compile a set of Fortran scripts that make a few Lapack and Blas calls. I've been able to use automatic offloading for the ZGETRF Lapack routine, which is LU factorization by increasing my problem size so that the matrices the ZGETRF call is processing are, in fact, greater than 8192 x 8192. However, there are some other Lapack and Blas routines not supported for automatic offloading in the scripts as well. I'm wondering if also denoting some of those routines for offloading will be worth it, because explicit offloading for me in the past has only increased computational time.

It's worth noting I'm using mpiifort to keep the MPICH2 calls inside the code intact. If that is the source of the slowdown, let me know.

Thanks.

Somehow this package got installed with my Visual Fortran installation.  How do I uninstall it under Windows 7?  I can't find it listed in the installed programs in the Win control panel uninstaller.

Hi
After success with SVM in batch mode, I'm now looking at KMeans. In SVM I could get the model out with something like this:

services::SharedPtr<svm::training::Result> trainingResults = algorithm.getResult();
auto model = trainingResults->get(classifier::training::model);

I could then serialize/deserialize the model and do predictions by setting the model back into the algorithm.

Kmeans seems to be different, I can get the results from
services::SharedPtr<kmeans::Result> trainingResults = algorithm.getResult();

Then get the centroids but I can't see how to do predictions from the centroids?
Do you have to load them up into the kMeans algorithm with your new data and kick it off with a special value of iterations for example?
How can I persist the model? Do I just persist the centroids numeric table?

Many thanks

Intel® DAAL 2017  (Sep 2016)

Intel MKL Benchmarks package includes Intel® Optimized LINPACK Benchmark,  Intel® Optimized MP LINPACK Benchmark for Clusters, and Intel® Optimized High Performance Conjugate Gradient Benchmark from the latest Intel MKL release. Use the links in the table below to download package for Linux*, Windows* or OS X*.

By downloading any sample package you accept the End User License Agreement

Check out the new and the latest Intel® Data Analytics Acceleration Library (Intel® DAAL) 2017 release! The open source Intel DAAL project is also updated accordingly. 

What's new in Intel DAAL:

• Introducing Python programming language API
• Introducing Neural Networks functionality
  • Uniform and Xavier initialization methods
  • Layers
    • Two-dimensional convolutional
    • One-, two-, and three-dimensional max pooling
    • One-, two-, and three-dimensional average pooling
    • Spatial pyramid pooling, stochastic pooling and locally connected layers
    • Fully connected
    • Dropout
    • Logistic
    • Hyperbolic tangent
    • Rectifier Linear Unit (ReLu)
    • Parametric Rectifier Linear Unit (pReLu)
    • Smooth Rectifier Linear Unit (smooth ReLu)
    • Softmax with cross-entropy loss
    • Absolute value (abs)
    • Batch normalization
    • Local response normalization
    • Local contrast normalization
    • Concat
    • Split
  • Optimization solvers
    • Stochastic gradient descent
    • Mini-batch stochastic gradient descent
    • Stochastic limited memory Broyden–Fletcher–Goldfarb–Shanno (lBFGS)
    • Mini-batch Adagrad optimization solver
  • Objective functions
    • Mean squared error (MSE)
  • Tensor: Support multiple data layouts, axes control, and computation of tensor size
  • Other: Support for user-defined memory allocation to store layer results in Neural Networks
• Added Ridge Linear regression algorithm in batch/online/distributed processing mode
• Added support for quality metrics for linear regression
• Added z-score normalization
• Improved performance for QR, SVD, PCA, variance-covariance, linear regression, Expectation Maximization (EM) for Gaussian Mixture Models (GMM), K-means, and the Naïve Bayes algorithms on the 2nd generation of Intel® Xeon Phi™ processors (codenamed Knights Landing), as well as on the Intel® Xeon® E5-xxxx v3 (codenamed Haswell) and the Intel® Xeon® E5-xxxx v4 (codenamed Broadwell) processors. 
• Bug fixes and other improvements in the library and its documentation

Checkout Online Release notes for more information. 

Intel® Math Kernel Library for Deep Neural Networks (Intel® MKL-DNN) is now available on the Github (https://github.com/01org/mkl-dnn) as an open source performance library for Deep Learning (DL) applications intended for acceleration of DL frameworks on Intel® architecture. Intel® MKL-DNN includes highly vectorized and threaded building blocks to implement convolutional neural networks (CNN) with C and C++ interfaces.

For an overview of the project, documentation, and other information, please visit https://01.org/mkl-dnn 

Hi,

I'm now building numpy on my Windows 7 following this guide: https://software.intel.com/en-us/articles/building-numpyscipy-with-intel-mkl-and-intel-fortran-on-windows. I also posted this question under the guide, if it's not proper please delete it. 

I have Intel Parallel Studio XE 2017 installed including MKL, icl and ifort. The version of numpy is the latest one because I've downloaded just now. 

When I did the step 4, complied numpy with the indicated line: 

python setup.py config --compiler=intelemw build_clib --compiler=intelemw build_ext --compiler=intelemw install

then an error was raised, the key part is

LINK : fatal error LNK1104: cannot open file 'libiomp5md.lib'

while actually the file libiomp5md.lib did lie in the directory I configured in site.cfg, and it was found during the process as the following log said. So I have no idea where the problem is.

Could anyone give me some hints? Thanks.

Bo

The log is as follows:

Running from numpy source directory.
blas_opt_info:
blas_mkl_info:
  FOUND:
    libraries = ['mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md']
    library_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\mkl\\lib\\intel64_win', 'C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\compiler\\lib\\intel64_win']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\parallel_studio_xe_2017.0.036\\compilers_and_libraries_2017\\windows\\mkl\\include']

  FOUND:
    libraries = ['mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md']
    library_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\mkl\\lib\\intel64_win', 'C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\compiler\\lib\\intel64_win']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\parallel_studio_xe_2017.0.036\\compilers_and_libraries_2017\\windows\\mkl\\include']

F2PY Version 2
lapack_opt_info:
openblas_lapack_info:
  libraries openblas not found in ['C:\\Python27\\lib', 'C:\\', 'C:\\Python27\\libs']
  NOT AVAILABLE

lapack_mkl_info:
mkl_info:
  FOUND:
    libraries = ['mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md']
    library_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\mkl\\lib\\intel64_win', 'C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\compiler\\lib\\intel64_win']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\parallel_studio_xe_2017.0.036\\compilers_and_libraries_2017\\windows\\mkl\\include']

  FOUND:
    libraries = ['mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md', 'mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md']
    library_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\mkl\\lib\\intel64_win', 'C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\compiler\\lib\\intel64_win']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\parallel_studio_xe_2017.0.036\\compilers_and_libraries_2017\\windows\\mkl\\include']

  FOUND:
    libraries = ['mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md', 'mkl_lapack95_lp64', 'mkl_blas95_lp64', 'mkl_intel_lp64', 'mkl_intel_thread', 'mkl_core', 'libiomp5md']
    library_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\mkl\\lib\\intel64_win', 'C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2017.0.109\\windows\\compiler\\lib\\intel64_win']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\parallel_studio_xe_2017.0.036\\compilers_and_libraries_2017\\windows\\mkl\\include']

C:\Python27\lib\distutils\dist.py:267: UserWarning: Unknown distribution option: 'define_macros'
  warnings.warn(msg)
running config
running build_clib
running build_src
build_src
building py_modules sources
building library "npymath" sources
Could not locate executable icc
Could not locate executable ecc
customize GnuFCompiler
Could not locate executable g77
Could not locate executable f77
customize IntelVisualFCompiler
Found executable C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2017.0.109\windows\bin\intel64\ifort.exe
Found executable C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2017.0.109\windows\bin\intel64\ifort.exe
customize AbsoftFCompiler
Could not locate executable f90
customize CompaqVisualFCompiler
Could not locate executable DF
customize IntelItaniumVisualFCompiler
Could not locate executable efl
customize Gnu95FCompiler
Could not locate executable gfortran
Could not locate executable f95
customize G95FCompiler
Could not locate executable g95
customize IntelEM64VisualFCompiler
customize IntelEM64VisualFCompiler
customize IntelEM64VisualFCompiler using config
C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2017.0.109\windows\bin\intel64\icl.exe /c /nologo /O3 /MD /W3 /Qstd=c99 /QxHost /fp:strict /Qopenmp -Inumpy\core\src\private -Inumpy\core\src -Inumpy\core -Inumpy\core\src\npymath -Inumpy\core\src\multiarray -Inumpy\core\src\umath -Inumpy\core\src\npysort -IC:\Python27\include -IC:\Python27\PC /Tc_configtest.c /Fo_configtest.obj
Found executable C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2017.0.109\windows\bin\intel64\icl.exe
xilink /nologo /INCREMENTAL:NO _configtest.obj /OUT:_configtest.exe /MANIFEST /MANIFESTFILE:_configtest.exe.manifest
Found executable C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2017.0.109\windows\bin\intel64\xilink.exe
LINK : fatal error LNK1104: cannot open file 'libiomp5md.lib'
failure.
removing: _configtest.c _configtest.obj

I installed pydaal and I can't find the code examples anywhere, not even on github. Any clue as to where I can get them?

A Jupyter Notebook based tutorial series of using pyDAAL (the Python API for Intel DAAL) is now available on Github:

https://github.com/daaltces/pydaal-tutorials 

It is designed for new users to quickly ramp up understanding of the pyDAAL API and usage model. There are only a few examples at this time, but we will gradually grow to cover more DAAL algorithms. You are more than welcome to use, share, fork, and contribute. 

First, I'd like to congratulate Intel on the awesome initiatives to (1) make MKL freely available through the Community Licensing, (2) develop the super fast Intel Distribution for Python and (3) make it available through Continuum's conda.

There's only one thing that is really missing now: to provide a mkl-devel conda package so that we are able to build other packages that depend on MKL using conda-build locally or on the conda-forge infrastructure.

Continuum already have an internal private mkl-devel package which they use to build their version of numpy and other packages, but they are not able to publish it due to licensing restrictions (despite MKL having a free version already), please see:

https://github.com/ContinuumIO/anaconda-recipes/issues/50

and:

https://github.com/ContinuumIO/anaconda-issues/issues/888

Could Intel make this package available, or provide a way to make it available?

Thanks!

Hi,

I know about the OOC functionality, but if I just want to use the in-core option (iparm(60) = 0), how can I make sure pardiso uses virtual memory (windows 7)? In a large solve with 6 million unknowns, I get the error code -2. After phase 1 I calculate the memory requirement from pardiso as around 30gb, which is more than my available ram, but much less than my available virtual memory. 

Related to this is the following question: what is the exact criterion which causes error code -2?

Best,
Jens

I'm wondering if it's possible to run Pardiso on more than one thread per core on linux, or if certain behind-the-scenes optimisations have been set. That is, with the following env:

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px Menlo}
span.s1 {font-variant-ligatures: no-common-ligatures}

$ env | grep PARDISO

MKL_DOMAIN_NUM_THREADS=MKL_DOMAIN_PARDISO=56

And with the following hardware configuration, per (excerpted) /proc/cpuinfo:

processor   : 55

vendor_id   : GenuineIntel

cpu family  : 6

model       : 63

model name  : Intel(R) Xeon(R) CPU E5-2695 v3 @ 2.30GHz

Our 2x14 core machine still only produces the following (excerpted) Pardiso call summary:

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Helvetica; -webkit-text-stroke: #000000}
p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Helvetica; -webkit-text-stroke: #000000; min-height: 14.0px}
span.s1 {font-kerning: none}

Statistics:

===========

Parallel Direct Factorization is running on 28 OpenMP

< Linear system Ax = b >

            number of equations:           89317

            number of non-zeros in A:      57771613

            number of non-zeros in A (%): 0.724180

BTW, our OS is CentOS release 6.6, with 64 bit icc, composer_xe_2015.3.187

Any info much appreciated,

-Greg

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px Menlo}
span.s1 {font-variant-ligatures: no-common-ligatures}