MLX: Apple silicon 용 Machine Learning 프레임워크

MLX: Apple silicon 용 Machine Learning 프레임워크 - 02.Regression example

감자 24.01.02

1,622 13 0

facebook twitter kakao link

13 0

facebook twitter kakao link

DEVOTEE 요약: 이 블로그는 MLX 라이브러리를 사용한 기계학습에 대해 설명하고 있다. 선형회귀와 로지스틱회귀를 통한 학습 예시를 제공하며, MLX와 numpy의 성능을 비교한다. 이를 통해 사용자가 MLX를 사용하는 방법을 이해하고, 성능 차이를 확인하는데 도움을 준다.

DEVOTEE 추천 블로그

MLX examples

몇 가지 Machine learning 예제들을 통해 MLX 사용법을 익혀보도록 하겠습니다.

사실 numpy 나 torch, scipy 등의 라이브러리에 익숙하다면 그렇게 크게 어렵지 않기 때문에 잘 따라할 수 있습니다. 메쏘드들이 거의 유사하게 구현되었거든요.

Linear Regression

아주 간단한 Linear Regression 예제를 돌려보겠습니다.

임의의 함수를 만들어 데이터를 합성하고, 해당 데이터를 이용해 역으로 함수를 approximate 하는 예제입니다.

우선 관련 모듈들을 import 하고 hyperparam 들을 세팅해줍니다.

import mlx.core as mx
import time

num_features = 100
num_examples = 1_000
test_examples = 100
num_iters = 10_000  # iterations of SGD
lr = 0.01  # learning rate for SGD

임의의 선형 함수를 만들어주고, 임의의 input 데이터를 만들어줍니다.

모두 mx.random.normal 을 이용해 랜덤하게 만들어 주겠습니다.label 값의 경우 만들어진 input 데이터를 함수에 통과시키고, 작은 noise 를 부여하여 만들어줍니다.

# 임의의 선형 함수 True parameters
w_star = mx.random.normal((num_features,))

# Input examples (design matrix)
X = mx.random.normal((num_examples, num_features))

# Noisy labels
eps = 1e-2 * mx.random.normal((num_examples,))
y = X @ w_star + eps

별도의 테스트셋도 만들어주겠습니다.

# Test set generation
X_test = mx.random.normal((test_examples, num_features))
y_test = X_test @ w_star

이제 Loss function 과 Gradient function 을 만들어줍니다. 우선은 MSE loss 를 사용합니다.$${L} _{MSE}=\frac{1}{2n}\sum{(y-pred)^2}$$

Gradient function 의 경우 수식을 구현해서 사용해도 좋지만, mx.grad 를 이용하면 loss function 으로부터 바로 얻어낼 수 있습니다.

$$\ nabla{L}_{MSE}=\frac{1}{n}X^T(Xw-y)$$

# MSE Loss function
def loss_fn(w):
    return 0.5 * mx.mean(mx.square(X @ w - y))

# Gradient function
grad_fn = mx.grad(loss_fn)

# 실제 수학적 구현은 아래와 같다. 수행시간도 동일함
# def grad_fn(w):
#     return X.T @ (X @ w-y) * (1/num_examples)

이제 Linear regression 을 위한 parameter 를 초기화하고 SGD (Stochastic Gradient Descent) 방법을 이용해 학습합니다.

Test set 에 대해서 MSE 값이 크게 감소한 것을 확인할 수 있습니다.

또 수행시간은 약 0.9초 남짓하게 걸리네요. (M1 맥북 pro 기준입니다)

Throughput 은 약 10K iter/s 입니다.

# Initialize random parameter
w = 1e-2 * mx.random.normal((num_features,))

# Test error (MSE)
pred_test = X_test @ w
test_error = mx.mean(mx.square(y_test - pred_test))
print(f"Initial test error (MSE): {test_error.item():.5f}")

Initial test error (MSE): 90.18447

# Training by SGD
start = time.time()
for its in range(1,num_iters+1):
    grad = grad_fn(w)
    w = w - lr * grad
mx.eval(w)
end = time.time()
print(f"Training elapsed time: {end-start} seconds")
print(f"Throughput {num_iters/(end-start):.3f} it/s")

Training elapsed time: 0.9663820266723633 seconds
Throughput 10347.875 it/s

# Test error (MSE)
pred_test = X_test @ w
test_error = mx.mean(mx.square(y_test - pred_test))
print(f"Final test error (MSE): {test_error.item():.5f}")

Final test error (MSE): 0.00001

CPU 연산과의 수행시간 비교

만약 numpy array 를 사용했다면 그 속도는 어떻게 될까요?

동일한 구현 방식으로 연산 수행 속도를 비교해 보겠습니다.

물론 numpy 모듈은 Apple silicon 의 GPU 를 사용할 수 없습니다.

# True parameters
w_star = np.random.normal(size=(num_features,1))

# Input examples (design matrix)
X = np.random.normal(size=(num_examples, num_features))

# Noisy labels
eps = 1e-2 * np.random.normal(size=(num_examples,1))
y = np.matmul(X, w_star) + eps

# Test set generation
X_test = np.random.normal(size=(test_examples, num_features))
y_test = np.matmul(X_test, w_star)

def loss_fn(w):
    return 0.5 * np.mean(np.square(np.matmul(X, w) - y))

def grad_fn(w):
    return np.matmul(X.T, np.matmul(X, w)-y) * (1/num_examples)

w = 1e-2 * np.random.normal(size=(num_features,1))

pred_test = np.matmul(X_test, w)
test_error = np.mean(np.square(y_test - pred_test))
print(f"Initial test error (MSE): {test_error.item():.5f}")

Initial test error (MSE): 51.48214

start = time.time()
for its in range(1,num_iters+1):
    grad = grad_fn(w)
    w = w - lr * grad
    
end = time.time()
print(f"Training elapsed time: {end-start} seconds")
print(f"Throughput {num_iters/(end-start):.3f} it/s")

Training elapsed time: 1.2018659114837646 seconds
Throughput 8320.396 it/s

pred_test = np.matmul(X_test, w)
test_error = np.mean(np.square(y_test - pred_test))
print(f"Final test error (MSE): {test_error.item():.5f}")

Final test error (MSE): 0.00001

수행시간이 약 1.2초로 증가한 것을 확인할 수 있습니다.

Throughput은 8.3K 정도로 약간 감소했네요.

feature 도 100개 정도인 아주 간단한 linear regression 에서도 이 정도의 속도 증가는 기대할 수 있겠습니다.

드라마틱한 변화는 발생하지 않는 걸 볼 수 있습니다.

Logistic regression

Logistic regression 도 잠깐 테스트를 해보도록 하겠습니다.

모든 과정은 Linear regression 과 동일하지만 Label 이 0,1 로 구성된다는 것, activation function 을 사용한다는 것, Loss 로 Cross entropy 를 사용한다는 것만 다릅니다.

import time

import mlx.core as mx

num_features = 100
num_examples = 1_000
num_iters = 10_000
lr = 0.01

# True parameters
w_star = mx.random.normal((num_features,1))

# Input examples
X = mx.random.normal((num_examples, num_features))

# Labels (with noise)
eps = 1e-2 * mx.random.normal((num_examples,1))
y_bool = (X @ w_star + eps) > 0
y = mx.where(y_bool, 1.0, 0.0)

# Initialize random parameters
w = 1e-2 * mx.random.normal((num_features,1))

def loss_fn(w):
    logits = X @ w
    y_hat = mx.sigmoid(logits)
    return mx.mean(-y * mx.log(y_hat) - (1-y) * mx.log(1-y_hat))

# def grad_fn(w):
#     logits = X @ w
#     y_hat = mx.sigmoid(logits)
#     return X.T @ (y_hat - y) * (1/num_examples)
    
grad_fn = mx.grad(loss_fn)

tic = time.time()
for iters in range(num_iters):
    grad = grad_fn(w)
    w = w - lr * grad

    # Early stopping
    preds = (X @ w) > 0
    acc = mx.mean(preds == y_bool)
    if acc > 0.95:
        print(f"Early stop at iteration {iters}")
        break

mx.eval(w)
toc = time.time()

loss = loss_fn(w)
final_preds = (X @ w) > 0
acc = mx.mean(final_preds == y)

throughput = iters / (toc - tic)
print(
    f"Loss {loss.item():.5f}, Accuracy {acc.item():.5f} "
    f"Throughput {throughput:.5f} (it/s)"
)

Early stop at iteration 256
Loss 0.44712, Accuracy 0.95000 Throughput 1627.90763 (it/s)

import time

import numpy as np

num_features = 100
num_examples = 1_000
num_iters = 10_000
lr = 0.01

# True parameters
w_star = np.random.normal(size=(num_features,))

# Input examples
X = np.random.normal(size=(num_examples, num_features))

# Labels
eps = 1e-2 * np.random.normal(size=(num_examples,))
y_bool = np.matmul(X, w_star) + eps > 0
y = np.where(y_bool, 1.0, 0.0)


# Initialize random parameters
w = 1e-2 * np.random.normal(size=(num_features,))

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def loss_fn(w):
    logits = np.matmul(X, w)
    y_hat = sigmoid(logits)
    return np.mean(-y * np.log(y_hat) - (1-y) * np.log(1-y_hat))

def grad_fn(w):
    logits = np.matmul(X, w)
    y_hat = sigmoid(logits)
    return np.matmul(X.T, y_hat - y) * (1/num_examples)

tic = time.time()
for iters in range(num_iters):
    grad = grad_fn(w)
    w = w - lr * grad

    # Early stopping
    preds = np.matmul(X, w) > 0
    acc = np.mean(preds == y_bool)
    if acc > 0.95:
        print(f"Early stop at iteration {iters}")
        break

toc = time.time()

loss = loss_fn(w)
final_preds = np.matmul(X, w) > 0
acc = np.mean(final_preds == y)

throughput = iters / (toc - tic)
print(
    f"Loss {loss.item():.5f}, Accuracy {acc.item():.5f} "
    f"Throughput {throughput:.5f} (it/s)"
)

Early stop at iteration 297
Loss 0.40303, Accuracy 0.95100 Throughput 3858.49777 (it/s)

재미있게도 numpy 를 사용하는 것이 throughput 이 더 이득이네요.

추후 multi-layer perceptron 처럼 행렬 연산이 더 무거워지는 경우 어떻게 되는지 확인해보도록 하겠습니다.

#PyTorch #Tensorflow #iOS

등록

DEVOTEE를 활성화 시키면
지금 작성한 댓글에 AI가 댓글을 달아줍니다.

익명

감자 님의 최신 블로그

LLaDA: Diffusion language model과 LLM reversal curse

몇 달 전에 Gemini Diffusion 모델이라는 게 나왔다는 뉴스를 봤다. 일단 첫 번째로 Diffusion으로 어떻게 language model을 만든거지? 가 궁금했고, 두 번째로는 데모 비디오를 봤는데 미친듯이 빠른 속도가 눈에 띄었다. (꼭 데모 비디오 보시길!) 그래서 한번 근간이 되는 논문을 읽어보기로 했다. Alibaba Ant group 에서 써낸 Large Language Diffusion Models, 일명 LLaDA 라는 모델을 제안한 논문이 되겠다 (근데 마지막 A가 제목에는 없음...Large Language diffusion with mAsking 라고 함) 꽤 재미있게 읽은데다가, 중간에 LLM reversal curse 라는 개념...
Think-fusion 의 여러가지 방식 (feat. DeepSeek-V3.1, GPT-5)

2025년 LLM 필드에서 가장 중요한 키워드 하나를 꼽으라면 바로 ＇Reasoning＇일 것입니다. Test-time-computing을 통해서 LLM은 사람처럼 생각하는 과정을 거쳐 답변을 이끌어냈고, 이는 다양한 벤치마크 성능을 극적으로 끌어올렸습니다. 하지만 이 Reasoning 모델은 일반 사용자들 (단순한 태스크에 LLM을 적용하려는) 에게는 큰 영향을 주지 못했습니다. 금방 대답할 수 있는 질문들에도 쓸데없는 사고과정을 거치면서 답변을 기다리는 사용자들을 지치게 만들곤 했기 때문입니다. 그래서 제안된 방식 중 하나가 바로 Think-fusion입니다. 이전 블로그 글에서 Qwen3에 적용된 Hybrid think mode 에 대해서 살펴본 바 있습니다...
NVIDIA Isaac Sim 으로 배우는 Physical AI (3회차 모임)

안녕하세요, Devocean OpenLab NVIDIA Isaac Sim 으로 배우는 Physical AI에 참여하고 있는 조재경입니다. 3회차 스터디는 T타워 1층에 있는 T-library 에서 진행하였습니다. 상기님도 와주셔서 저희를 응원해주셨네요!! 이번 3회차에는 1) 로봇을 제어하기 위한 미들웨어인 ROS2의 기초와 2) 유저의 발화만으로 로봇을 컨트롤하여 원하는 곳으로 이동시키기 위해 제안된 효율적 방법론인 ReMEMbR 에 대해서 알아보았습니다. ROS2의 기초는 스터디 대장님인 유석님께서 설명해 주셨습니다. 아주 명쾌한 설명에 무릎을 탁 치면서 감탄하며 들었네요. ReMEMbR는 제가 세미나 형식으로 준비해서 발표를 해보았는데요. 오랜만에 로봇 관련...
Qwen3 의 Hybrid thinking mode

2025년 4월 29일 새벽에 Alibaba의 Qwen3 가 릴리즈되었다. Qwen3 공식 블로그 Technical report 가 공개되지 않고, 블로그로만 공개되었기 때문에 학습이 어떻게 이루어졌는지는 아주 제한적으로 공개되었다. 모델은 총 6개로 MoE 모델 2개와 Dense 모델 6개로 구성되었다. MoE 모델은 235B (22B activate), 30B (3B activate), Dense 모델은 32B, 14B, 8B, 4B, 1.7B, 0.6B 의 사이즈다. 블로그 글에 따르면 각각 가장 큰 모델만 학습한 뒤, strong-to-weak distillation 을 통해 나머지 모델들을 학습한 것으로 보인다. 아마도 base model 들은 pruni...

DEVOTEE 추천 블로그

MLX: Apple silicon 용 Machine Learning 프레임워크 - 03.Multi-Layer Perceptron example

Multi-Layer Perceptron (MLP) example MNIST 데이터셋을 이용한 Multi-Layer Perceptron (MLP) 예제를, MLX 를 이용해 구현해보도록 하겠습니다. Torch 로 구현하는 것과 어떤 차이를 보이는지 비교해볼 예정입니다. MLX 를 이용한 MLP 구현 우선 관련 모듈들을 import 해주겠습니다. import mlx.core as mx import mlx.nn as nn import mlx.optimizers as optim import numpy as np from matplotlib import pyplot as plt from time import time MLP class 를 하나 만들어줍니다. 잘 보면 to...
MLX: Apple silicon 용 Machine Learning 프레임워크 - 04.LLM inference example

LLM Inference with MLX MLX 라이브러리를 이용한 LLM inference 에서 어느 정도 속도의 이득을 볼 수 있을지 확인해보도록 하겠습니다. Transformer를 기반으로 하는 LLaMA 모델을 직접 구현하는 작업이 포함되어 있습니다. 갑자기 드는 개인적 의견 LLaMA 모델을 직접구현해야 한다...이런 부분에서 단점이 보이는데...PyTorch 같은 경우 huggingface 라는 엄청난 플랫폼과의 연계성이 돋보입니다. 코드 4~5줄만으로도 huggingface hub 에 있는 모델들을 다운받고 inference 할 수 있습니다. 뭐 MLX 는 아직 나온지 얼마 안된 라이브러리니까 개선의 여지는 많이 남아있습니다만, torch 와 동일한 ...
고등학생도 이해하는 Transformer (Deep Learning) #5 (업데이트)

고등학생도 이해하는 Transformer (Deep Learning) #1 고등학생도 이해하는 Transformer (Deep Learning) #2 고등학생도 이해하는 Transformer (Deep Learning) #3 고등학생도 이해하는 Transformer (Deep Learning) #4 지난 시간에 내적의 의미를 다시 한번 생각 해봤습니다. 내적의 의미를 알면 계산을 하지 않아도 어느 벡터가 서로 얼마나 유사한지, 영향을 주는지, 닮았는지 형태만 보고서도 알 수 있었습니다. 지금까지 나온 이야기가 딥러닝과 너무 거리가 멀다는 이야기가 있어서 이번에는 실제 코드로 내적을 실습 해보고자 합니다. (아~ 고등학생은 Python 모를려나요? ^^；； 대신 그...
실험으로 알아보는 LLM 파인튜닝 최적화 가이드 Part 2.

들어가며 지난 1편에서는 배치 크기(Batch size)와 시퀀스 길이(Sequence length)를 조정하는 방법부터, 학습 과정에서 메모리를 아껴 쓰는 최적화 기법까지 다양한 기법을 살펴보았습니다. 요약하자면 비싼 GPU 메모리를 어떻게 효율적으로 활용해 적은 자원으로도 최적의 학습을 할 수 있을지를 고민해봤습니다. 이번에는 학습 알고리즘 최적화에 대해 이야기해보려고 합니다. 전편보다 조금 더 전문적인 내용을 다뤄야 할 것 같은데, 개발자의 시선으로 쉽게 풀어보려고 합니다. 이번 글에서는 다음과 같은 주제를 다루고 있습니다. Optimizer 선택 기준 Learning Rate가 모델 학습에 미치는 영향 Learning Rate 스케줄링이 필요한 이유 연산 ...

목록으로

DEVOCEAN

로그인 선택

미리보기

커뮤니티

글 등록

임시저장함

데보션 블로그 게재 요청