패키지 상세v13.12.9

ml_linalg

SIMD 기반의 선형 대수 및 통계, 숫자 데이터 효율적 조작

AndroidiOSWebmacOSWindowsLinux

pub.dev API 문서 소스 코드

30일 다운로드: 2만
좋아요: 88
Pub 점수: 150

패키지 설치

flutter pub add ml_linalg

패키지 개요

공개 정보를 바탕으로 생성한 선택 가이드입니다.

ml_linalg는 Dart용 고성능, SIMD 최적화 라이브러리로 선형 대수 및 통계 연산을 제공합니다. 효율적인 수치 데이터 조작을 위해 설계되어 머신러닝, 과학 계산, 데이터 분석에 필수적인 빠른 행렬 및 벡터 계산을 가능하게 합니다. Android, iOS, Web, macOS, Windows, Linux 등 다양한 플랫폼을 지원하여 밀도 높은 수학 처리가 필요한 크로스플랫폼 애플리케이션에 적합합니다. 성능을 우선시해 설계되었으며, 저수준 최적화를 활용하여 속도와 정밀도를 제공합니다.

사용 사례

머신러닝 모델 훈련
과학 시뮬레이션
데이터 변환 파이프라인
실시간 분석
통계 모델링
수치 최적화

주요 기능

SIMD 가속 계산
크로스 플랫폼 호환성
행렬 및 벡터 연산
통계 함수
모든 지원되는 플랫폼에서 높은 성능
효율적인 메모리 사용

적합한 대상

ML 애플리케이션을 개발하는 개발자
Dart를 사용하는 데이터 과학자
빠른 수치 처리가 필요한 응용 프로그램
다중 플랫폼 수학 중심 앱
성능 중심의 수치 코드

고려 사항

선형 대수에 대한 이해가 필요합니다
숫자 데이터 워크로드에 가장 적합
문서가 제한될 수 있습니다
일반적인 용도로 사용하기 위한 것이 아님
특정 하드웨어 기능에 최적화됨

원본 README

연결된 소스 저장소의 README 원문 스냅샷입니다. 최신 내용은 저장소에서 확인하세요.

SIMD-based linear algebra and statistics for data science with Dart

TABLE OF CONTENTS

What is linear algebra
What is SIMD
Vectors
Matrices
- Matrix operations
vector_math and ml_linalg differences
Contacts

Linear algebra

In a few words, linear algebra is a branch of mathematics that works with vectors and matrices. Vectors and matrices are practical tools in real-life applications, such as machine learning algorithms. These significant mathematical entities are implemented in plenty of programming languages.

As Dart offers developers good instrumentation, e.g. highly optimized virtual machine, specific data types and rich out-of-the-box library, Dart-based implementation of vectors and matrices has to be quite performant.

Among numerous standard Dart tools, there are SIMD data types, and support of SIMD computational architecture served as inspiration for creating this library.

What is SIMD?

SIMD stands for Single instruction, multiple data - it's a computer architecture that allows to perform uniform mathematical operations in parallel on a list-like data structure. For instance, one has two arrays:

final a = [10, 20, 30, 40];
final b = [50, 60, 70, 80];

and one needs to add these arrays element-wise. Using the regular architecture this operation could be done in the following manner:

final c = List(4);

c[0] = a[0] + b[0]; // operation 1
c[1] = a[1] + b[1]; // operation 2
c[2] = a[2] + b[2]; // operation 3
c[3] = a[3] + b[3]; // operation 4

As you may have noticed, we need to do 4 operations one by one in a row using regular computational approach. But with help of SIMD architecture we may do one arithmetic operation on several operands in parallel, thus element-wise sum of two arrays can be done for just one step:

Vectors

A couple of words about the underlying architecture

The library contains two high performant vector classes based on Float32x4 and Float64x2 data types - Float32x4Vector and Float64x2Vector (the second one is generated from the source code of the first vector's implementation)

Most of element-wise operations in the first one are performed in four "threads" and in the second one - in two "threads".

Implementation of both classes is hidden from the library's users. You can create a Float32x4Vector or a Float64x2Vector instance via Vector factory (see examples below).

One can create Float32x4-based vectors the following way:

import 'package:ml_linalg/linalg.dart';

void main() {
  final vector = Vector.fromList([1.0, 2.0, 3.0, 4.0, 5.0], dtype: DType.float32);
}

or simply

import 'package:ml_linalg/linalg.dart';

void main() {
  final vector = Vector.fromList([1.0, 2.0, 3.0, 4.0, 5.0]);
}

since dtype is set to DType.float32 by default.

One can create Float64x2-based vectors the following way:

import 'package:ml_linalg/linalg.dart';

void main() {
  final vector = Vector.fromList([1.0, 2.0, 3.0, 4.0, 5.0], dtype: DType.float64);
}

Float32x4-based vectors are much faster than Float64x2-based ones, but Float64x2-based vectors are more precise since they use 64 bits to represent numbers in the memory versus 32 bits for Float32x4-based vectors.

Nevertheless, Float32x4 representation uses by default since usually 32 bits is enough for number precision, and along with that, this representation is more performant.

The vectors are immutable: once created, the vector cannot be changed. All the vector operations lead to creation of a new vector instance (of course, if the operation is supposed to return a Vector).

Both classes implement Iterable<double> interface, so it's possible to use them as regular iterable collections.

It's possible to use vector instances as keys for HashMap and similar data structures and to look up a value by the vector-key, since the hash code for equal vectors is the same:

import 'package:ml_linalg/vector.dart';

final map = HashMap<Vector, bool>();

map[Vector.fromList([1, 2, 3, 4, 5])] = true;

print(map[Vector.fromList([1, 2, 3, 4, 5])]); // true
print(Vector.fromList([1, 2, 3, 4, 5]).hashCode == Vector.fromList([1, 2, 3, 4, 5]).hashCode); // true

Vector benchmarks

To see the performance benefits provided by the library's vector classes, one may visit benchmark directory: one may find there a baseline benchmark - element-wise summation of two regular List instances and a benchmark of a similar operation, but performed on two Float32x4Vector instances on the same amount of elements and compare the timings:

Baseline benchmark (executed on Macbook Air mid 2017), 2 regular lists each with 10,000,000 elements:

Actual benchmark (executed on Macbook Air mid 2017), 2 vectors each with 10,000,000 elements:

It took 15 seconds to create a new regular list by summing the elements of two lists, and 0.7 second to sum two vectors - the difference is significant.