머신러닝을 위한 시뮬레이션 데이터 처리

머신러닝에서 데이터를 효과적으로 활용하기 위해서는 시뮬레이션 환경에서 수집된 데이터를 적절하게 처리하는 과정이 필수적이다. Unity 기반의 로봇 시뮬레이션에서도 다양한 로봇 동작 데이터를 수집하고 이를 분석하여 머신러닝 모델을 훈련시키기 위한 데이터셋으로 활용할 수 있다. 여기서는 Unity 시뮬레이션에서 수집된 데이터를 머신러닝 모델로 사용할 수 있도록 처리하는 과정을 설명한다.

데이터 수집 및 전처리

Unity에서 시뮬레이션된 로봇의 데이터를 수집하려면 먼저 수집할 데이터의 종류와 형식을 정의해야 한다. 일반적으로 로봇의 상태와 센서 데이터를 포함한 다양한 정보들이 포함된다. 수집할 수 있는 데이터의 예시는 다음과 같다.

로봇의 위치 $\mathbf{p}(t)$ , 속도 $\mathbf{v}(t)$ , 가속도 $\mathbf{a}(t)$
로봇의 관성 측정 장치(IMU) 데이터: 각속도 $\boldsymbol{\omega}(t)$ , 가속도 $\mathbf{a}_{imu}(t)$
로봇의 제어 입력: $\mathbf{u}(t)$
환경과의 상호작용 데이터: 충돌 여부, 거리, 접촉력 등

각 데이터는 시간에 따른 변화로 기록되며, 이를 시간 기반 데이터셋으로 관리할 수 있다. 데이터 수집 과정에서는 필요한 정보가 모두 기록될 수 있도록 각 프레임에서 데이터를 캡처해야 한다.

public class DataLogger : MonoBehaviour
{
    public GameObject robot;
    private List<string> dataLog = new List<string>();

    void Update()
    {
        // 로봇의 위치와 속도 기록
        Vector3 position = robot.transform.position;
        Vector3 velocity = robot.GetComponent<Rigidbody>().velocity;

        // 시간, 위치, 속도를 로그에 추가
        dataLog.Add(Time.time.ToString() + "," + position.ToString() + "," + velocity.ToString());
    }

    void OnApplicationQuit()
    {
        // 로그 파일 저장
        System.IO.File.WriteAllLines("simulation_data.csv", dataLog.ToArray());
    }
}

위의 예제 코드에서는 Unity에서 로봇의 위치와 속도를 매 프레임마다 기록하고 시뮬레이션이 종료될 때 해당 데이터를 파일로 저장한다.

데이터 정규화

수집된 시뮬레이션 데이터는 머신러닝 모델을 훈련시키기 전에 정규화(Normalization) 과정을 거쳐야 한다. 정규화는 데이터의 스케일 차이를 제거하여 모델 훈련 과정에서 특정한 값들이 지나치게 큰 영향을 미치지 않도록 하는 것이다. 정규화는 다양한 방법으로 수행될 수 있으나, 대표적으로 Min-Max 정규화와 Z-score 정규화가 있다.

Min-Max 정규화

Min-Max 정규화는 데이터의 값들을 [0, 1] 범위로 변환한다. 데이터 $x$ 에 대해 Min-Max 정규화는 다음과 같이 수행된다.

$x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}}$

여기서 $x_{\min}$ 과 $x_{\max}$ 은 각각 데이터 $x$ 의 최소값과 최대값을 나타낸다.

Z-score 정규화

Z-score 정규화는 데이터의 평균을 0으로 하고, 분산을 1로 만든다. 이를 통해 각 데이터가 평균으로부터 얼마나 떨어져 있는지를 기준으로 정규화된다. Z-score 정규화는 다음과 같이 정의된다.

$x' = \frac{x - \mu}{\sigma}$

여기서 $\mu$ 는 데이터의 평균, $\sigma$ 는 데이터의 표준편차를 나타낸다.

정규화 과정에서 데이터의 값들이 지나치게 크거나 작은 경우 머신러닝 모델의 학습 효율성이 떨어질 수 있으므로, 반드시 정규화 과정을 거쳐야 한다.

데이터 분할

머신러닝 모델을 훈련하기 위해서는 수집된 데이터를 훈련 데이터와 검증 데이터, 그리고 테스트 데이터로 나누는 것이 중요하다. 일반적으로 데이터셋을 3:1:1의 비율로 나누는 것이 일반적이다.

훈련 데이터: 모델이 학습하는 데 사용되는 데이터.
검증 데이터: 모델의 성능을 평가하고 하이퍼파라미터 튜닝에 사용되는 데이터.
테스트 데이터: 학습 과정에서 전혀 사용되지 않으며, 모델의 최종 성능을 평가하는 데 사용되는 데이터.

이러한 데이터 분할은 시뮬레이션 데이터를 시간 순서대로 나누는 방식이나 무작위로 나누는 방식으로 수행될 수 있다. 시간에 의존적인 데이터의 경우, 시간 순서를 유지하면서 데이터를 나누는 것이 중요하다.

public class DataSplitter
{
    public static (List<string>, List<string>, List<string>) SplitData(List<string> data, float trainRatio, float valRatio)
    {
        int total = data.Count;
        int trainCount = Mathf.FloorToInt(total * trainRatio);
        int valCount = Mathf.FloorToInt(total * valRatio);

        List<string> trainData = data.GetRange(0, trainCount);
        List<string> valData = data.GetRange(trainCount, valCount);
        List<string> testData = data.GetRange(trainCount + valCount, total - trainCount - valCount);

        return (trainData, valData, testData);
    }
}

위 코드에서는 데이터를 훈련, 검증, 테스트로 나누는 기능을 제공한다. trainRatio와 valRatio는 훈련과 검증 데이터의 비율을 결정하며, 이를 통해 전체 데이터를 각 용도에 맞게 분할한다.

데이터 변환

머신러닝 모델을 훈련하기 위해서는 시뮬레이션 데이터를 적절한 형태로 변환해야 한다. Unity에서 수집된 데이터는 대개 CSV 파일이나 텍스트 파일 형태로 저장되므로 이를 벡터 또는 행렬로 변환하는 작업이 필요하다. 각 로봇의 상태와 센서 데이터를 벡터로 변환하여 모델에 입력할 수 있다.

데이터는 보통 다음과 같은 구조로 변환된다:

입력 데이터 $\mathbf{X}$ : 로봇의 상태와 센서 데이터.
출력 데이터 $\mathbf{Y}$ : 예측하고자 하는 값 (예: 로봇의 위치나 각도).

$\mathbf{X} = \begin{bmatrix} x_1 & x_2 & \dots & x_n \end{bmatrix}$

$\mathbf{Y} = \begin{bmatrix} y_1 & y_2 & \dots & y_n \end{bmatrix}$

여기서 $\mathbf{X}$ 는 각 입력 벡터 $\mathbf{x}_i$ 로 구성되며, $\mathbf{Y}$ 는 출력 값들을 포함한 벡터이다.

예를 들어, 로봇의 위치 데이터를 입력으로 하고, 예측할 위치 값을 출력으로 하는 문제에서는 입력 벡터 $\mathbf{X}$ 가 로봇의 현재 상태, 속도, 가속도 등의 데이터를 포함하게 된다.

public class DataTransformer
{
    public static (List<float[]>, List<float[]>) TransformData(List<string> rawData)
    {
        List<float[]> inputData = new List<float[]>();
        List<float[]> outputData = new List<float[]>();

        foreach (var dataLine in rawData)
        {
            string[] splitData = dataLine.Split(',');
            float[] input = Array.ConvertAll(splitData.Take(3).ToArray(), float.Parse);  // 입력 데이터 (위치, 속도)
            float[] output = Array.ConvertAll(splitData.Skip(3).ToArray(), float.Parse); // 출력 데이터 (다음 위치 등)
            inputData.Add(input);
            outputData.Add(output);
        }

        return (inputData, outputData);
    }
}

이 코드에서는 CSV 형식의 시뮬레이션 데이터를 벡터로 변환하는 방법을 보여준다. 입력 데이터와 출력 데이터를 분리하여 머신러닝 모델에 적합한 형식으로 변환한다.

데이터 증강

머신러닝 모델이 충분한 데이터를 학습할 수 있도록, 데이터 증강 기법을 사용할 수 있다. 데이터 증강은 실제로 수집된 데이터를 다양한 방식으로 변형하여 데이터셋을 확장하는 방법이다. 특히 Unity에서 시뮬레이션된 데이터는 다양한 변형을 적용하여 더욱 다양한 환경에서 모델을 학습시킬 수 있다.

데이터 증강 기법

잡음 추가: 수집된 데이터에 노이즈를 추가하여 실제 환경에서 발생할 수 있는 불확실성을 반영한다. 예를 들어, 센서 데이터에 Gaussian 노이즈를 추가하여 더 현실적인 데이터를 생성할 수 있다.

$\mathbf{x}' = \mathbf{x} + \mathcal{N}(0, \sigma^2)$

여기서 $\mathbf{x}'$ 는 노이즈가 추가된 데이터, $\mathbf{x}$ 는 원본 데이터, $\mathcal{N}(0, \sigma^2)$ 는 평균이 0이고 분산이 $\sigma^2$ 인 가우시안 분포로부터 샘플링된 노이즈이다.

데이터 변환: 로봇의 위치나 속도를 다양한 방향으로 회전시키거나 축을 기준으로 반사시켜 새로운 데이터를 생성할 수 있다. 예를 들어, 로봇의 위치를 $\theta$ 만큼 회전시키는 경우 회전 변환 행렬을 사용한다.

$\mathbf{R}(\theta) = \begin{bmatrix} \cos \theta & -\sin \theta \\ \sin \theta & \cos \theta \end{bmatrix}$

$\mathbf{p}' = \mathbf{R}(\theta) \cdot \mathbf{p}$

여기서 $\mathbf{p}$ 는 로봇의 원래 위치, $\mathbf{p}'$ 는 회전된 위치이다.

시간 축 변환: 로봇의 움직임 데이터를 시간 축에서 변형하여 시뮬레이션된 시간보다 빠르거나 느린 동작 데이터를 생성할 수 있다. 이 방식은 실제 환경에서의 다양한 시간적 변화를 모델에 반영하는 데 유용하다.

public class DataAugmentation
{
    public static List<float[]> AddNoise(List<float[]> data, float noiseLevel)
    {
        System.Random rand = new System.Random();
        List<float[]> noisyData = new List<float[]>();

        foreach (var entry in data)
        {
            float[] noisyEntry = new float[entry.Length];
            for (int i = 0; i < entry.Length; i++)
            {
                noisyEntry[i] = entry[i] + (float)(rand.NextDouble() * 2 - 1) * noiseLevel;
            }
            noisyData.Add(noisyEntry);
        }

        return noisyData;
    }

    public static List<float[]> RotateData(List<float[]> data, float theta)
    {
        List<float[]> rotatedData = new List<float[]>();
        float cosTheta = Mathf.Cos(theta);
        float sinTheta = Mathf.Sin(theta);

        foreach (var entry in data)
        {
            float x = entry[0];
            float y = entry[1];

            float newX = x * cosTheta - y * sinTheta;
            float newY = x * sinTheta + y * cosTheta;

            rotatedData.Add(new float[] { newX, newY, entry[2] });
        }

        return rotatedData;
    }
}

위 코드에서는 데이터를 증강하기 위해 노이즈를 추가하거나 로봇의 위치 데이터를 회전시키는 방법을 보여준다. 이러한 변환을 통해 더 다양한 학습 데이터셋을 확보할 수 있다.

특성 엔지니어링

특성 엔지니어링은 원본 데이터에서 의미 있는 특성을 추출하거나 변형하여 모델의 성능을 향상시키는 과정이다. 시뮬레이션 데이터를 머신러닝에 사용할 때는 단순한 원시 데이터를 입력으로 사용하는 것보다, 적절한 특성 변환을 통해 데이터를 더 유용하게 만들 수 있다.

예를 들어, 로봇의 위치 데이터뿐만 아니라, 위치 변화율(속도), 가속도, 각속도 등의 정보를 추가로 특성으로 사용할 수 있다. 이러한 추가 특성들은 로봇의 동작을 더 잘 설명하는 데 도움이 될 수 있다.

예시: 위치 변화로 속도 추정

$\mathbf{v}(t) = \frac{\mathbf{p}(t) - \mathbf{p}(t-\Delta t)}{\Delta t}$

위 수식을 통해 로봇의 위치 $\mathbf{p}(t)$ 에서 시간 간격 $\Delta t$ 동안의 변화를 바탕으로 속도 $\mathbf{v}(t)$ 를 계산할 수 있다.

public class FeatureEngineering
{
    public static List<float[]> ComputeVelocity(List<float[]> positionData, float deltaTime)
    {
        List<float[]> velocityData = new List<float[]>();

        for (int i = 1; i < positionData.Count; i++)
        {
            float[] prevPosition = positionData[i - 1];
            float[] currPosition = positionData[i];

            float[] velocity = new float[3];
            for (int j = 0; j < 3; j++)
            {
                velocity[j] = (currPosition[j] - prevPosition[j]) / deltaTime;
            }

            velocityData.Add(velocity);
        }

        return velocityData;
    }
}

이 코드에서는 위치 데이터를 사용하여 시간 차이를 기반으로 속도를 계산하는 기능을 제공한다. 이처럼 특성 엔지니어링을 통해 추가적인 의미 있는 정보를 데이터셋에 포함시킬 수 있다.

데이터 셋 정리 및 라벨링

머신러닝 모델을 학습시키기 위해서는 수집된 데이터를 정리하고, 각 데이터에 대한 라벨을 할당하는 과정이 필요하다. 데이터 셋 정리는 데이터를 사용하기 편한 구조로 만드는 과정이며, 라벨링은 각 데이터에 대해 예측해야 할 값을 부여하는 작업이다.

시계열 데이터 정리

로봇 시뮬레이션 데이터는 일반적으로 시간에 따른 변화를 포함하고 있기 때문에, 시계열 데이터를 모델에 적합하게 정리해야 한다. 시계열 데이터를 사용하려면 각 시간 단계에서의 입력 데이터와 그에 상응하는 출력 데이터를 매핑하는 방식으로 데이터를 구성할 수 있다.

예를 들어, 로봇의 위치와 속도 데이터를 입력으로 사용하고, 다음 시간 단계에서의 위치를 출력으로 사용하는 방식이다. 이를 통해 모델은 주어진 시간의 데이터를 바탕으로 미래의 상태를 예측할 수 있다.

$\mathbf{X}_t = \begin{bmatrix} \mathbf{p}(t) \\ \mathbf{v}(t) \end{bmatrix}, \quad \mathbf{Y}_t = \mathbf{p}(t + \Delta t)$

이때 $\mathbf{X}_t$ 는 현재 시간 $t$ 에서의 입력 벡터, $\mathbf{Y}_t$ 는 다음 시간 $t + \Delta t$ 에서의 출력 벡터이다.

라벨링

라벨링 작업은 데이터에 대한 목표 값을 설정하는 과정이다. 일반적으로 로봇의 행동이나 상태를 예측하는 문제에서는 위치, 속도, 가속도 등을 라벨로 사용할 수 있다. 예를 들어, 자율 주행 로봇의 경우 현재 위치와 속도를 입력으로 사용하고, 다음 시간의 위치를 라벨로 사용하여 모델이 미래의 위치를 예측할 수 있도록 학습시킨다.

public class DataLabeling
{
    public static List<(float[], float[])> CreateLabeledData(List<float[]> positionData, List<float[]> velocityData)
    {
        List<(float[], float[])> labeledData = new List<(float[], float[])>();

        for (int i = 0; i < positionData.Count - 1; i++)
        {
            float[] inputData = new float[6];
            float[] outputData = new float[3];

            // 입력 데이터 (위치와 속도)
            Array.Copy(positionData[i], 0, inputData, 0, 3);
            Array.Copy(velocityData[i], 0, inputData, 3, 3);

            // 출력 데이터 (다음 위치)
            Array.Copy(positionData[i + 1], outputData, 3);

            labeledData.Add((inputData, outputData));
        }

        return labeledData;
    }
}

위 코드에서는 위치와 속도 데이터를 입력으로 사용하고, 다음 시간 단계에서의 위치를 출력 라벨로 설정하는 방식으로 라벨링을 수행한다. 이렇게 생성된 라벨 데이터를 통해 모델은 주어진 입력에 따라 미래의 상태를 예측하는 학습을 수행할 수 있다.

시뮬레이션 데이터를 머신러닝 모델에 적용하기

시뮬레이션 데이터를 수집하고 전처리한 후, 이를 머신러닝 모델에 적용하는 방법을 고려해야 한다. 일반적으로 머신러닝 모델은 다양한 형태로 데이터를 학습할 수 있으며, 로봇 시뮬레이션에서는 시계열 데이터를 사용하는 순환 신경망(RNN)이나 LSTM(Long Short-Term Memory) 같은 모델이 자주 사용된다.

LSTM과 같은 모델은 시간 의존적인 데이터를 다룰 수 있는 능력이 있어, 로봇의 상태 데이터를 학습하고 예측하는 데 적합하다. 로봇의 움직임을 예측하는 문제에서는 시간에 따른 연속적인 데이터를 모델이 학습하여 다음 상태를 예측하도록 학습한다.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# 모델 정의
model = Sequential()
model.add(LSTM(50, input_shape=(timesteps, feature_count)))
model.add(Dense(3))  # 예측할 위치 출력

model.compile(optimizer='adam', loss='mse')

# 모델 학습
model.fit(trainX, trainY, epochs=10, batch_size=32)

위 Python 예제에서는 LSTM 모델을 사용하여 시뮬레이션 데이터를 기반으로 로봇의 다음 위치를 예측하는 방법을 보여준다. trainX와 trainY는 전처리된 시뮬레이션 데이터로 구성되며, 이를 모델에 학습시켜 예측 작업을 수행할 수 있다.

이와 같이 시뮬레이션 데이터를 머신러닝 모델에 적용하기 위해서는 적절한 전처리와 모델 정의가 필요하며, 학습된 모델은 이후 로봇의 행동을 예측하거나 제어하는 데 사용될 수 있다.