Ver2.0 ๐ฎ Unity ML-Agents๋ก ๋๋ํ AI ๊ฒ์ ์บ๋ฆญํฐ ๋ง๋ค๊ธฐ: ์ด๋ณด์๋ ๋ฐ๋ผํ ์ ์๋ ๊ฐํํ์ต ๊ฐ์ด๋ ๐ค

๐ฎ Unity ML-Agents๋ก ๋๋ํ AI ๊ฒ์ ์บ๋ฆญํฐ ๋ง๋ค๊ธฐ: ์ด๋ณด์๋ ๋ฐ๋ผํ ์ ์๋ ๊ฐํํ์ต ๊ฐ์ด๋ ๐ค
์๋ ํ์ธ์, ๊ฒ์ ๊ฐ๋ฐ์ ๊ด์ฌ ์๋ ์ฌ๋ฌ๋ถ! ์ค๋์ Unity ML-Agents๋ฅผ ํ์ฉํด์ ์ธ๊ณต์ง๋ฅ ๊ฒ์ ์บ๋ฆญํฐ๋ฅผ ํ๋ จ์ํค๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณผ๊ฒ์. ๐ "์ด? AI๋ผ๋? ๋๋ฌด ์ด๋ ค์ด ๊ฑฐ ์๋?" ๋ผ๊ณ ์๊ฐํ์๋ ๋ถ๋ค! ๊ฑฑ์ ๋ ธ๋ ธ~ ์ด ๊ธ์์๋ ์ต๋ํ ์ฝ๊ณ ์ฌ๋ฐ๊ฒ ์ค๋ช ํด๋๋ฆด๊ฒ์! ๋ง์น ์นดํก์ผ๋ก ์๋ค ๋จ๋ฏ์ด ใ ใ ใ
๊ฒ์ ์ AI ์บ๋ฆญํฐ๊ฐ ํ๋ ์ด์ด์ฒ๋ผ ํ์ตํ๊ณ ์งํํ๋ ๋ชจ์ต์ ์ง์ ๋ง๋ค์ด๋ณผ ์ ์๋ค๋ฉด ์ผ๋ง๋ ์ ๊ธฐํ ๊น์? ๋ฐ๋ก ๊ทธ ๋ง๋ฒ ๊ฐ์ ๊ฒฝํ์ Unity ML-Agents๊ฐ ๊ฐ๋ฅํ๊ฒ ํด์ค๋๋ค!
๐ ๋ชฉ์ฐจ
- Unity ML-Agents๋ ๋ฌด์์ธ๊ฐ์?
- ๊ฐํํ์ต์ ๊ธฐ๋ณธ ๊ฐ๋ ์ดํดํ๊ธฐ
- ๊ฐ๋ฐ ํ๊ฒฝ ์ค์ ํ๊ธฐ
- ์ฒซ ๋ฒ์งธ ML-Agents ํ๋ก์ ํธ ๋ง๋ค๊ธฐ
- AI ์์ด์ ํธ ํ๋ จ์ํค๊ธฐ
- ํ๋ จ ๊ฒฐ๊ณผ ๋ถ์ ๋ฐ ์ต์ ํ
- ์ค์ ํ๋ก์ ํธ: AI ํ๋ซํฌ๋จธ ๊ฒ์ ์บ๋ฆญํฐ ๋ง๋ค๊ธฐ
- ์์ฃผ ๋ฌป๋ ์ง๋ฌธ๊ณผ ๋ฌธ์ ํด๊ฒฐ
1. Unity ML-Agents๋ ๋ฌด์์ธ๊ฐ์? ๐ค
Unity ML-Agents(Machine Learning Agents)๋ Unity์์ ๊ฐ๋ฐํ ์คํ์์ค ํ๋ก์ ํธ๋ก, ๊ฒ์ ๊ฐ๋ฐ์๋ค์ด ๊ฐํํ์ต์ ํตํด ์ง๋ฅ์ ์ธ AI ์บ๋ฆญํฐ๋ฅผ ๋ง๋ค ์ ์๊ฒ ๋์์ฃผ๋ ํดํท์ด์์. ์ฝ๊ฒ ๋งํด์, ๊ฒ์ ์บ๋ฆญํฐ๊ฐ ์ค์ค๋ก ํ์ตํ๊ณ ๋ฐ์ ํ ์ ์๊ฒ ํด์ฃผ๋ ๋ง๋ฒ ๊ฐ์ ๋๊ตฌ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ฉ๋๋ค! โจ
ML-Agents์ ์ฃผ์ ํน์ง ๐
1. ๊ฐํํ์ต(Reinforcement Learning)์ ๊ฒ์ ํ๊ฒฝ์ ์ฝ๊ฒ ์ ์ฉ ๊ฐ๋ฅ
2. ๋ชจ๋ฐฉํ์ต(Imitation Learning)์ผ๋ก ์ฌ๋์ ํ๋ ์ด ์คํ์ผ ํ์ต ๊ฐ๋ฅ
3. ์ปค๋ฆฌํ๋ผ ํ์ต(Curriculum Learning)์ผ๋ก ๋์ด๋๋ฅผ ์ ์ง์ ์ผ๋ก ๋์ด๋ฉฐ ํ๋ จ
4. ๋ฉํฐ์์ด์ ํธ ํ๊ฒฝ์์ ํ๋ ฅ ๋๋ ๊ฒฝ์ ํ์ต ์ง์
5. Python API๋ฅผ ํตํ ๊ณ ๊ธ ํ๋ จ ๊ธฐ๋ฅ ์ ๊ณต
"๊ทผ๋ฐ ์ด๊ฑฐ ์ค์ ๋ก ์ด๋์ ์ฐ์ด๋ ๊ฑฐ์์?" ๋ผ๋ ์ง๋ฌธ์ด ๋ค๋ฆฌ๋ ๊ฒ ๊ฐ๋ค์! ใ ใ ใ ์ค์ ๋ก ML-Agents๋ ๋ค์๊ณผ ๊ฐ์ ๊ณณ์ ํ์ฉ๋ฉ๋๋ค:
์ฌ๋ฅ๋ท์์๋ ๊ฒ์ ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ๋ ๋ถ๋ค์ด ML-Agents๋ฅผ ํ์ฉํ ํ๋ก์ ํธ๋ฅผ ๋ง์ด ์ ๋ณด์ด๊ณ ์์ด์. ํนํ ์ธ๋ ๊ฒ์ ๊ฐ๋ฐ์๋ค์๊ฒ ํฐ ๋์์ด ๋๋ ๊ธฐ์ ์ด๋๋๋ค! ๐
2. ๊ฐํํ์ต์ ๊ธฐ๋ณธ ๊ฐ๋ ์ดํดํ๊ธฐ ๐ง
ML-Agents๋ฅผ ์ ๋๋ก ํ์ฉํ๋ ค๋ฉด ๊ฐํํ์ต์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์์์ผ ํด์. ๊ทผ๋ฐ ๋๋ฌด ์ด๋ ต๊ฒ ์๊ฐํ์ง ๋ง์ธ์! ๊ฐํํ์ต์ ๊ทธ๋ฅ "์ํ์ฐฉ์ค๋ฅผ ํตํด ๋ฐฐ์ฐ๋ ๋ฐฉ์"์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋ฉ๋๋ค.
๊ฐํํ์ต์ ๋ง์น ์์ด๊ฐ ๊ฑธ์๋ง๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ๊ณผ ๋น์ทํด์. ์ฒ์์๋ ๋์ด์ง๊ณ ์คํจํ์ง๋ง, ๊ณ์ ์๋ํ๋ฉด์ ์ด๋ค ํ๋์ด ์ข์ ๊ฒฐ๊ณผ(๋ณด์)๋ฅผ ๊ฐ์ ธ์ค๋์ง ํ์ตํ๊ฒ ๋ฉ๋๋ค.
๊ฐํํ์ต์ ํต์ฌ ์์ ๐
๊ฐํํ์ต์์๋ ์ ๋ค์ด์ด๊ทธ๋จ์ฒ๋ผ ์์ด์ ํธ(Agent)๊ฐ ํ๊ฒฝ(Environment)๊ณผ ์ํธ์์ฉํ๋ฉด์ ํ์ตํด์. ์์ด์ ํธ๋ ํน์ ํ๋(Action)์ ์ทจํ๊ณ , ํ๊ฒฝ์ ์๋ก์ด ์ํ(State)์ ๋ณด์(Reward)์ ์ ๊ณตํฉ๋๋ค.
์๋ฅผ ๋ค์ด๋ณผ๊น์? ๐ฎ
- ๐ค ์์ด์ ํธ: ํ๋ซํฌ๋จธ ๊ฒ์์ ์ฃผ์ธ๊ณต ์บ๋ฆญํฐ
- ๐ ํ๊ฒฝ: ๊ฒ์ ๋ ๋ฒจ๊ณผ ์ฅ์ ๋ฌผ๋ค
- ๐โโ๏ธ ํ๋: ์ ํ, ๋ฌ๋ฆฌ๊ธฐ, ๊ณต๊ฒฉ ๋ฑ
- ๐ ์ํ: ์บ๋ฆญํฐ์ ์์น, ์ฃผ๋ณ ์ ์ ์์น, ์ฒด๋ ฅ ๋ฑ
- ๐ ๋ณด์: ์ฝ์ธ ํ๋(+์ ์), ์ ์ฒ์น(+์ ์), ์ฃฝ์(-์ ์)
์ด๋ฐ ๊ตฌ์กฐ์์ AI๋ ์ต๋ํ ๋ง์ ๋ณด์์ ์ป๋ ๋ฐฉํฅ์ผ๋ก ํ๋ ํจํด์ ํ์ตํ๊ฒ ๋ฉ๋๋ค. ์ฒ์์๋ ๋๋คํ๊ฒ ํ๋ํ๋ค๊ฐ ์ ์ ์ด๋ค ํ๋์ด ์ข์ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ค๋์ง ํ์ ํ๊ฒ ๋์ฃ . ์ด๊ฒ ๋ฐ๋ก ๊ฐํํ์ต์ ๋ง๋ฒ์ด์์! โจ
3. ๊ฐ๋ฐ ํ๊ฒฝ ์ค์ ํ๊ธฐ ๐ ๏ธ
์, ์ด์ ์ค์ ๋ก ML-Agents๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ ํ๊ฒฝ์ ์ค์ ํด๋ณผ๊น์? ๊ฑฑ์ ๋ง์ธ์, ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์์! ใ ใ ใ
ํ์ํ ๋๊ตฌ๋ค ๐งฐ
- Unity Hub & Unity Editor (2020.3 LTS ์ด์ ๋ฒ์ ๊ถ์ฅ)
- Python (3.6 ~ 3.9 ๋ฒ์ )
- ML-Agents ํจํค์ง
- PyTorch (ML-Agents์ ๋ฐฑ์๋๋ก ์ฌ์ฉ)
์ค์น ๊ณผ์ ๋จ๊ณ๋ณ ๊ฐ์ด๋ ๐
1๋จ๊ณ: Unity ์ค์นํ๊ธฐ
Unity Hub๋ฅผ ๋จผ์ ์ค์นํ๊ณ , ๊ทธ ๋ค์์ Unity Editor๋ฅผ ์ค์นํด์ฃผ์ธ์. Unity Hub๋ ์ฌ๋ฌ ๋ฒ์ ์ Unity๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ฝ๊ฒ ํด์ฃผ๋ ํ๋ก๊ทธ๋จ์ด์์.
Unity Hub ๋ค์ด๋ก๋: https://unity.com/download
2๋จ๊ณ: Python ์ค์นํ๊ธฐ
Python์ ์ค์นํ ๋๋ "Add Python to PATH" ์ต์ ์ ๊ผญ ์ฒดํฌํด์ฃผ์ธ์! ์ด๋ ๊ฒ ํ๋ฉด ๋ช ๋ น ํ๋กฌํํธ์์ Python์ ๋ฐ๋ก ์คํํ ์ ์์ด์.
Python ๋ค์ด๋ก๋: https://www.python.org/downloads/
3๋จ๊ณ: ML-Agents ์ค์นํ๊ธฐ
์ด์ ๋ช ๋ น ํ๋กฌํํธ(์๋์ฐ) ๋๋ ํฐ๋ฏธ๋(๋งฅ)์ ์ด๊ณ ๋ค์ ๋ช ๋ น์ด๋ฅผ ์ ๋ ฅํด์ฃผ์ธ์:
pip install mlagents
์ด ๋ช ๋ น์ด๋ก ML-Agents Python ํจํค์ง๊ฐ ์ค์น๋ฉ๋๋ค. ์ด ํจํค์ง๋ Unity ๋ด์ ์์ด์ ํธ๋ฅผ ํ๋ จ์ํค๋ ๋ฐ ํ์ํ ๋๊ตฌ๋ค์ ์ ๊ณตํด์.
4๋จ๊ณ: Unity์ ML-Agents ํจํค์ง ์ถ๊ฐํ๊ธฐ
Unity ํ๋ก์ ํธ๋ฅผ ์ด๊ณ Window > Package Manager๋ฅผ ์ ํํฉ๋๋ค. "+" ๋ฒํผ์ ํด๋ฆญํ๊ณ "Add package from git URL..."์ ์ ํํ ํ ๋ค์ URL์ ์ ๋ ฅํด์ฃผ์ธ์:
com.unity.ml-agents
๐ก ๊ฟํ! Unity ๋ฒ์ ๊ณผ ML-Agents ๋ฒ์ ์ด ํธํ๋๋์ง ํ์ธํ๋ ๊ฒ์ด ์ค์ํด์! ์ต์ ๋ฒ์ ์ด ํญ์ ์ต์ ์ ์๋ ์ ์์ผ๋, ๊ณต์ ๋ฌธ์์์ ๊ถ์ฅํ๋ ๋ฒ์ ์ ํ์ธํด๋ณด์ธ์.
์ด๋ ๊ฒ ์ค์ ์ด ์๋ฃ๋๋ฉด ML-Agents๋ฅผ ์ฌ์ฉํ ์ค๋น๊ฐ ๋๋ฌ์ด์! ์ง์ง์ง~ ๐
4. ์ฒซ ๋ฒ์งธ ML-Agents ํ๋ก์ ํธ ๋ง๋ค๊ธฐ ๐
์ด๋ก ์ ์ด์ ์ถฉ๋ถํ ์์์ผ๋ ์ง์ ์์ผ๋ก ๋ง๋ค์ด๋ณผ ์ฐจ๋ก์์! ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์์ ์ธ "๊ณต ๊ตด๋ฆฌ๊ธฐ(Ball Rolling)" ๊ฒ์์ ๋ง๋ค์ด๋ณผ๊ฒ์. ์ด ๊ฒ์์์ AI๋ ๋ชฉํ ์ง์ ๊น์ง ๊ณต์ ๊ตด๋ฆฌ๋ ๋ฐฉ๋ฒ์ ํ์ตํ๊ฒ ๋ฉ๋๋ค.
ํ๋ก์ ํธ ์ค์ ํ๊ธฐ
- Unity Hub์์ ์ 3D ํ๋ก์ ํธ๋ฅผ ์์ฑํฉ๋๋ค.
- Package Manager์์ ML-Agents ํจํค์ง๋ฅผ ์ถ๊ฐํฉ๋๋ค.
- ์๋ก์ด ์ฌ(Scene)์ ๋ง๋ค๊ณ ์ ์ฅํฉ๋๋ค.
๊ฒ์ ํ๊ฒฝ ๋ง๋ค๊ธฐ
์ด์ ๊ฐ๋จํ ๊ฒ์ ํ๊ฒฝ์ ๋ง๋ค์ด๋ณผ๊ฒ์:
- ๋ฐ๋ฅ(Plane)์ ์์ฑํ๊ณ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํฉ๋๋ค.
- ๊ณต(Sphere)์ ์์ฑํ๊ณ Rigidbody ์ปดํฌ๋ํธ๋ฅผ ์ถ๊ฐํฉ๋๋ค.
- ๋ชฉํ ์ง์ (Target)์ผ๋ก ์ฌ์ฉํ ํ๋ธ๋ฅผ ์์ฑํ๊ณ ๋ค๋ฅธ ์์์ผ๋ก ์ค์ ํฉ๋๋ค.
- ๋ฒฝ(Wall)์ ๋ง๋ค์ด ๊ณต์ด ๋จ์ด์ง์ง ์๋๋ก ํฉ๋๋ค.
์์ด์ ํธ ์คํฌ๋ฆฝํธ ์์ฑํ๊ธฐ
์ด์ ML-Agents์ ํต์ฌ์ธ ์์ด์ ํธ ์คํฌ๋ฆฝํธ๋ฅผ ์์ฑํด๋ณผ๊ฒ์. ์ C# ์คํฌ๋ฆฝํธ๋ฅผ ๋ง๋ค๊ณ ์ด๋ฆ์ "RollerAgent"๋ก ์ง์ ํด์ฃผ์ธ์.
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
public class RollerAgent : Agent
{
Rigidbody rBody;
public Transform Target;
public float forceMultiplier = 10;
// ์ด๊ธฐํ ์ ํธ์ถ
public override void Initialize()
{
rBody = GetComponent<Rigidbody>();
}
// ์ํผ์๋ ์์ ์ ํธ์ถ
public override void OnEpisodeBegin()
{
// ์์ด์ ํธ ์์น ์ด๊ธฐํ
this.rBody.angularVelocity = Vector3.zero;
this.rBody.velocity = Vector3.zero;
this.transform.localPosition = new Vector3(0, 0.5f, 0);
// ๋ชฉํ๋ฌผ ์์น ๋๋คํ๊ฒ ์ค์
Target.localPosition = new Vector3(Random.value * 8 - 4, 0.5f, Random.value * 8 - 4);
}
// ๊ด์ธก ์ ๋ณด ์์ง
public override void CollectObservations(VectorSensor sensor)
{
// ๋ชฉํ๋ฌผ๊ณผ ์์ด์ ํธ์ ์์น
sensor.AddObservation(Target.localPosition);
sensor.AddObservation(this.transform.localPosition);
// ์์ด์ ํธ์ ์๋
sensor.AddObservation(rBody.velocity.x);
sensor.AddObservation(rBody.velocity.z);
}
// ํ๋ ์คํ
public override void OnActionReceived(ActionBuffers actionBuffers)
{
// ํ๋ ๊ฐ ๊ฐ์ ธ์ค๊ธฐ
Vector3 controlSignal = Vector3.zero;
controlSignal.x = actionBuffers.ContinuousActions[0];
controlSignal.z = actionBuffers.ContinuousActions[1];
// ํ ์ ์ฉํ๊ธฐ
rBody.AddForce(controlSignal * forceMultiplier);
// ๋ณด์: ๋ชฉํ์ ๊ฐ๊น์์ง์๋ก ์์ ์์ ๋ณด์
float distanceToTarget = Vector3.Distance(this.transform.localPosition, Target.localPosition);
// ๋ชฉํ์ ๋๋ฌํ์ ๋
if (distanceToTarget < 1.42f)
{
SetReward(1.0f);
EndEpisode();
}
// ํ๋ซํผ์์ ๋จ์ด์ก์ ๋
if (this.transform.localPosition.y < 0)
{
EndEpisode();
}
}
// ์๋ ํ
์คํธ์ฉ (์ ํ์ฌํญ)
public override void Heuristic(in ActionBuffers actionsOut)
{
var continuousActionsOut = actionsOut.ContinuousActions;
continuousActionsOut[0] = Input.GetAxis("Horizontal");
continuousActionsOut[1] = Input.GetAxis("Vertical");
}
}
์ด ์คํฌ๋ฆฝํธ๋ฅผ ๊ณต ์ค๋ธ์ ํธ์ ์ถ๊ฐํ๊ณ , Target ํ๋์ ๋ชฉํ ํ๋ธ๋ฅผ ์ฐ๊ฒฐํด์ฃผ์ธ์.
์ฝ๋ ์ค๋ช ๐
Initialize(): ์์ด์ ํธ๊ฐ ์์๋ ๋ ํ์ํ ์ปดํฌ๋ํธ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
OnEpisodeBegin(): ๊ฐ ํ์ต ์ํผ์๋๊ฐ ์์๋ ๋ ํ๊ฒฝ์ ์ด๊ธฐํํฉ๋๋ค.
CollectObservations(): ์์ด์ ํธ๊ฐ ํ๊ฒฝ์ ๊ด์ฐฐํ๋ ๋ฐ ํ์ํ ์ ๋ณด๋ฅผ ์์งํฉ๋๋ค.
OnActionReceived(): ์์ด์ ํธ๊ฐ ๊ฒฐ์ ํ ํ๋์ ์คํํ๊ณ ๋ณด์์ ๊ณ์ฐํฉ๋๋ค.
Heuristic(): ๊ฐ๋ฐ์๊ฐ ์ง์ ์์ด์ ํธ๋ฅผ ์กฐ์ํ ์ ์๊ฒ ํด์ฃผ๋ ํจ์์ ๋๋ค.
Behavior Parameters ์ค์ ํ๊ธฐ
์ด์ ์์ด์ ํธ์ Behavior Parameters ์ปดํฌ๋ํธ๋ฅผ ์ถ๊ฐํ๊ณ ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํด์ฃผ์ธ์:
- Behavior Name: RollerBall
- Vector Observation > Space Size: 8
- Actions > Continuous Actions Size: 2
- Behavior Type: Default
์ด๋ ๊ฒ ํ๋ฉด ๊ธฐ๋ณธ์ ์ธ ํ๊ฒฝ ์ค์ ์ด ์๋ฃ๋ฉ๋๋ค! ๐
5. AI ์์ด์ ํธ ํ๋ จ์ํค๊ธฐ ๐๏ธโโ๏ธ
์ด์ ์ง์ง ์ฌ๋ฏธ์๋ ๋ถ๋ถ์ด ์์๋ฉ๋๋ค! ์ฐ๋ฆฌ๊ฐ ๋ง๋ ์์ด์ ํธ๋ฅผ ํ๋ จ์์ผ๋ณผ ์ฐจ๋ก์์. ใ ใ ใ
ํ๋ จ ์ค์ ํ์ผ ๋ง๋ค๊ธฐ
ML-Agents๋ YAML ํ์ผ์ ์ฌ์ฉํด ํ๋ จ ์ค์ ์ ์ ์ํฉ๋๋ค. ํ๋ก์ ํธ ํด๋์ "rollerball_config.yaml"์ด๋ผ๋ ํ์ผ์ ๋ง๋ค๊ณ ๋ค์ ๋ด์ฉ์ ์ ๋ ฅํด์ฃผ์ธ์:
behaviors:
RollerBall:
trainer_type: ppo
hyperparameters:
batch_size: 64
buffer_size: 12000
learning_rate: 0.0003
beta: 0.001
epsilon: 0.2
lambd: 0.95
num_epoch: 3
learning_rate_schedule: linear
network_settings:
normalize: true
hidden_units: 128
num_layers: 2
vis_encode_type: simple
reward_signals:
extrinsic:
gamma: 0.99
strength: 1.0
max_steps: 500000
time_horizon: 64
summary_freq: 10000
์ฃผ์ ํ๋ผ๋ฏธํฐ ์ค๋ช ๐
trainer_type: ์ฌ์ฉํ ์๊ณ ๋ฆฌ์ฆ (PPO๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๊ฐํํ์ต ์๊ณ ๋ฆฌ์ฆ)
batch_size: ํ ๋ฒ์ ์ฒ๋ฆฌํ ๊ฒฝํ์ ์
learning_rate: ํ์ต ์๋ (๋๋ฌด ๋์ผ๋ฉด ๋ถ์์ , ๋๋ฌด ๋ฎ์ผ๋ฉด ๋๋ฆผ)
hidden_units & num_layers: ์ ๊ฒฝ๋ง์ ํฌ๊ธฐ์ ๊น์ด
max_steps: ์ด ํ๋ จ ์คํ ์
ํ๋ จ ์์ํ๊ธฐ
์ด์ ๋ช ๋ น ํ๋กฌํํธ(๋๋ ํฐ๋ฏธ๋)๋ฅผ ์ด๊ณ ํ๋ก์ ํธ ํด๋๋ก ์ด๋ํ ํ ๋ค์ ๋ช ๋ น์ด๋ฅผ ์คํํด์ฃผ์ธ์:
mlagents-learn rollerball_config.yaml --run-id=RollerBall1
๊ทธ๋ฆฌ๊ณ Unity ์๋ํฐ์์ Play ๋ฒํผ์ ๋๋ฌ์ฃผ์ธ์. ๊ทธ๋ฌ๋ฉด ํ๋ จ์ด ์์๋ฉ๋๋ค! ๐
ํ๋ จ์ด ์งํ๋๋ ๋์ ํฐ๋ฏธ๋์์๋ ๋ค์๊ณผ ๊ฐ์ ์ ๋ณด๋ฅผ ๋ณผ ์ ์์ด์:
- ๐ ํ๊ท ๋ณด์: ์์ด์ ํธ๊ฐ ๋ฐ๋ ํ๊ท ๋ณด์ ๊ฐ
- โฑ๏ธ ์ํผ์๋ ๊ธธ์ด: ํ ์ํผ์๋๊ฐ ๋๋ ๋๊น์ง ๊ฑธ๋ฆฌ๋ ํ๊ท ์๊ฐ
- ๐ง ์ ์ฑ ์์ค: ํ์ต ์๊ณ ๋ฆฌ์ฆ์ ์์ ์ฑ ์งํ
- ๐ ํ์ต ์๋: ์ด๋น ์ฒ๋ฆฌ๋๋ ํ๊ฒฝ ์คํ ์
๐ก ๊ฟํ! ํ๋ จ ์ค์๋ ์ฌ๋ฌ ๊ฐ์ ํ๊ฒฝ์ ๋์์ ์คํํ๋ฉด ํ๋ จ ์๋๋ฅผ ํฌ๊ฒ ๋์ผ ์ ์์ด์! ์ด๋ฅผ ์ํด --num-envs ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
ํ๋ จ์ ์ค์ ์ ๋ฐ๋ผ ๋ค๋ฅด์ง๋ง ๋ณดํต 30๋ถ~1์๊ฐ ์ ๋ ๊ฑธ๋ฆฝ๋๋ค. ๊ทธ๋์ โ ํ ์์ ์ปคํผ๋ฅผ ์ฆ๊ธฐ๋ ๊ฑด ์ด๋จ๊น์? ใ ใ ใ
6. ํ๋ จ ๊ฒฐ๊ณผ ๋ถ์ ๋ฐ ์ต์ ํ ๐
ํ๋ จ์ด ์๋ฃ๋๋ฉด results ํด๋์ ํ์ต๋ ๋ชจ๋ธ๊ณผ ํจ๊ป TensorBoard ๋ก๊ทธ๊ฐ ์ ์ฅ๋ฉ๋๋ค. ์ด ๋ก๊ทธ๋ฅผ ํตํด ํ๋ จ ๊ณผ์ ์ ์๊ฐ์ ์ผ๋ก ๋ถ์ํ ์ ์์ด์!
TensorBoard๋ก ๊ฒฐ๊ณผ ๋ถ์ํ๊ธฐ
๋ค์ ๋ช ๋ น์ด๋ก TensorBoard๋ฅผ ์คํํด๋ณด์ธ์:
tensorboard --logdir=results
๊ทธ๋ฌ๋ฉด ๋ธ๋ผ์ฐ์ ์์ http://localhost:6006์ผ๋ก ์ ์ํด ๋ค์ํ ์งํ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
์ฃผ์ ์งํ ์ค๋ช ๐
Environment/Cumulative Reward: ์์ด์ ํธ๊ฐ ๋ฐ์ ์ด ๋ณด์ (๋์์๋ก ์ข์)
Environment/Episode Length: ์ํผ์๋ ํ๊ท ๊ธธ์ด (๋ชฉํ์ ๋นจ๋ฆฌ ๋๋ฌํ ์๋ก ์งง์์ง)
Policy/Entropy: ์์ด์ ํธ ํ๋์ ๋ฌด์์์ฑ (ํ๋ จ์ด ์งํ๋ ์๋ก ๊ฐ์ํด์ผ ํจ)
Policy/Learning Rate: ํ์ต๋ฅ (๋ณดํต ์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ๊ฐ์)
๋ชจ๋ธ ์ฑ๋ฅ ์ต์ ํํ๊ธฐ
์ฒซ ๋ฒ์งธ ํ๋ จ ๊ฒฐ๊ณผ๊ฐ ๋ง์กฑ์ค๋ฝ์ง ์๋ค๋ฉด, ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ์ฑ๋ฅ์ ๊ฐ์ ํ ์ ์์ด์:
- ๋ณด์ ํจ์ ์กฐ์ : ๋ณด์ ๊ตฌ์กฐ๋ฅผ ๋ ์ธ๋ฐํ๊ฒ ์ค๊ณํด๋ณด์ธ์. ์๋ฅผ ๋ค์ด, ๋ชฉํ์ ๊ฐ๊น์์ง์๋ก ๋ ๋ง์ ๋ณด์์ ์ฃผ๋ ๋ฐฉ์์ผ๋ก ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
- ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋: learning_rate, batch_size ๋ฑ์ ๊ฐ์ ์กฐ์ ํด๋ณด์ธ์.
- ๋คํธ์ํฌ ๊ตฌ์กฐ ๋ณ๊ฒฝ: ๋ ํฌ๊ฑฐ๋ ์์ ์ ๊ฒฝ๋ง์ ์๋ํด๋ณด์ธ์.
- ๊ด์ธก ์ ๋ณด ๊ฐ์ : ์์ด์ ํธ์๊ฒ ๋ ์ ์ฉํ ์ ๋ณด๋ฅผ ์ ๊ณตํด๋ณด์ธ์.
์๋ฅผ ๋ค์ด, ๋ณด์ ํจ์๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์์ ํ ์ ์์ต๋๋ค:
// ๊ธฐ์กด ์ฝ๋
float distanceToTarget = Vector3.Distance(this.transform.localPosition, Target.localPosition);
if (distanceToTarget < 1.42f)
{
SetReward(1.0f);
EndEpisode();
}
// ๊ฐ์ ๋ ์ฝ๋
float distanceToTarget = Vector3.Distance(this.transform.localPosition, Target.localPosition);
// ๊ฑฐ๋ฆฌ์ ๋ฐ๋น๋กํ๋ ์์ ๋ณด์ ์ถ๊ฐ
SetReward(0.01f * (1.0f / (distanceToTarget + 0.1f)));
if (distanceToTarget < 1.42f)
{
SetReward(1.0f);
EndEpisode();
}
์ด๋ ๊ฒ ํ๋ฉด ์์ด์ ํธ๊ฐ ๋ชฉํ์ ๊ฐ๊น์์ง์๋ก ๋ ๋ง์ ๋ณด์์ ๋ฐ๊ฒ ๋์ด ํ์ต ์๋๊ฐ ๋นจ๋ผ์ง ์ ์์ด์!
7. ์ค์ ํ๋ก์ ํธ: AI ํ๋ซํฌ๋จธ ๊ฒ์ ์บ๋ฆญํฐ ๋ง๋ค๊ธฐ ๐ฎ
์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์กฐ๊ธ ๋ ๋ณต์กํ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณผ๊น์? 2D ํ๋ซํฌ๋จธ ๊ฒ์์ AI ์บ๋ฆญํฐ๋ฅผ ํ๋ จ์์ผ ๋ณด๊ฒ ์ต๋๋ค!
ํ๋ก์ ํธ ์ค์
- ์ Unity 2D ํ๋ก์ ํธ๋ฅผ ์์ฑํฉ๋๋ค.
- ML-Agents ํจํค์ง๋ฅผ ์ถ๊ฐํฉ๋๋ค.
- ๊ฐ๋จํ 2D ํ๋ซํผ ๋ ๋ฒจ์ ๋ง๋ญ๋๋ค (๋ฐ๋ฅ, ํ๋ซํผ, ์ฅ์ ๋ฌผ, ๋ชฉํ ์ง์ ๋ฑ).
ํ๋ ์ด์ด ์บ๋ฆญํฐ ์ค์
๊ฐ๋จํ ์บ๋ฆญํฐ๋ฅผ ๋ง๋ค๊ณ ๋ค์ ์ปดํฌ๋ํธ๋ฅผ ์ถ๊ฐํฉ๋๋ค:
- ๐ญ Sprite Renderer
- ๐ฆ Box Collider 2D
- ๐โโ๏ธ Rigidbody 2D
AI ์์ด์ ํธ ์คํฌ๋ฆฝํธ ์์ฑ
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
public class PlatformerAgent : Agent
{
[SerializeField] private Transform targetTransform;
[SerializeField] private float jumpForce = 7f;
[SerializeField] private float moveSpeed = 5f;
private Rigidbody2D rb;
private bool isGrounded;
private float groundCheckRadius = 0.1f;
[SerializeField] private LayerMask groundLayer;
[SerializeField] private Transform groundCheck;
public override void Initialize()
{
rb = GetComponent<Rigidbody2D>();
}
public override void OnEpisodeBegin()
{
// ์์น ์ด๊ธฐํ
transform.localPosition = new Vector3(-8f, 0f, 0f);
rb.velocity = Vector2.zero;
}
public override void CollectObservations(VectorSensor sensor)
{
// ์์ด์ ํธ ์์น ๋ฐ ์๋
sensor.AddObservation(transform.localPosition);
sensor.AddObservation(rb.velocity);
// ๋ชฉํ๊น์ง์ ์๋์ ์์น
sensor.AddObservation(targetTransform.localPosition - transform.localPosition);
// ๋ฐ๋ฅ์ ๋ฟ์๋์ง ์ฌ๋ถ
sensor.AddObservation(IsGrounded());
}
public override void OnActionReceived(ActionBuffers actionBuffers)
{
// ํ๋ ํด์
float moveX = actionBuffers.ContinuousActions[0];
bool jump = actionBuffers.DiscreteActions[0] == 1;
// ์ด๋
Vector2 moveForce = new Vector2(moveX * moveSpeed, 0);
rb.AddForce(moveForce);
// ์ ํ
if (jump && IsGrounded())
{
rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
}
// ๋ณด์ ๊ณ์ฐ
float distanceToTarget = Vector3.Distance(transform.localPosition, targetTransform.localPosition);
// ์์ ์๊ฐ ํจ๋ํฐ (๋นจ๋ฆฌ ๋ชฉํ์ ๋๋ฌํ๋๋ก ์ ๋)
AddReward(-0.001f);
// ๋ชฉํ์ ๋๋ฌํ์ ๋
if (distanceToTarget < 1.5f)
{
AddReward(1.0f);
EndEpisode();
}
// ๋จ์ด์ก์ ๋
if (transform.localPosition.y < -5f)
{
AddReward(-1.0f);
EndEpisode();
}
}
private bool IsGrounded()
{
return Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, groundLayer);
}
// ์๋ ํ
์คํธ์ฉ
public override void Heuristic(in ActionBuffers actionsOut)
{
var continuousActionsOut = actionsOut.ContinuousActions;
var discreteActionsOut = actionsOut.DiscreteActions;
continuousActionsOut[0] = Input.GetAxis("Horizontal");
discreteActionsOut[0] = Input.GetKey(KeyCode.Space) ? 1 : 0;
}
}
์ด ์คํฌ๋ฆฝํธ๋ฅผ ์บ๋ฆญํฐ์ ์ถ๊ฐํ๊ณ , Behavior Parameters ์ปดํฌ๋ํธ๋ ์ถ๊ฐํด์ฃผ์ธ์:
- Behavior Name: PlatformerAgent
- Vector Observation > Space Size: 8
- Actions > Continuous Actions Size: 1
- Actions > Discrete Branches Size: 1 (Branch 0 Size: 2)
์ด์ ํ๋ จ ์ค์ ํ์ผ์ ๋ง๋ค๊ณ ํ๋ จ์ ์์ํด๋ณด์ธ์! ๐
๐ฅ ๋์ ๊ณผ์ ! ๐ฅ
์ ์์ ๋ฅผ ํ์ฅํด์ ๋ค์ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์ธ์:
- ์ ์บ๋ฆญํฐ ์ถ๊ฐํ๊ธฐ (ํผํด์ผ ํจ)
- ์์ดํ ์์ง ๊ธฐ๋ฅ ์ถ๊ฐํ๊ธฐ
- ์ฌ๋ฌ ๋ ๋ฒจ ๋์์ธํด์ ์ปค๋ฆฌํ๋ผ ํ์ต ์ ์ฉํ๊ธฐ
์ด๋ฐ ๋์ ์ ํตํด ML-Agents์ ๋ค์ํ ๊ธฐ๋ฅ์ ์คํํด๋ณผ ์ ์์ด์!
์ฌ๋ฅ๋ท์์๋ ์ด๋ฐ AI ๊ฒ์ ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ๊ณ ๊ฑฐ๋ํ ์ ์์ด์. ์ฌ๋ฌ๋ถ์ด ๋ง๋ AI ์บ๋ฆญํฐ๋ ๊ฒ์ ์์คํ ์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ๊ณต์ ํด๋ณด๋ ๊ฑด ์ด๋จ๊น์? ๐ค
8. ์์ฃผ ๋ฌป๋ ์ง๋ฌธ๊ณผ ๋ฌธ์ ํด๊ฒฐ โ
Q: ํ๋ จ์ด ๋๋ฌด ์ค๋ ๊ฑธ๋ ค์. ์ด๋ป๊ฒ ํ๋ฉด ๋นจ๋ผ์ง๊น์?
A: ๋ค์ ๋ฐฉ๋ฒ์ ์๋ํด๋ณด์ธ์:
- ์ฌ๋ฌ ํ๊ฒฝ์ ๋์์ ์คํ (
--num-envsํ๋ผ๋ฏธํฐ ์ฌ์ฉ) - ๋ ๊ฐ๋จํ ์ ๊ฒฝ๋ง ๊ตฌ์กฐ ์ฌ์ฉ
- ๊ด์ธก ์ ๋ณด ์ค์ด๊ธฐ
- GPU๊ฐ ์๋ค๋ฉด ํ์ฉํ๊ธฐ
Q: ์์ด์ ํธ๊ฐ ์ ํ ํ์ตํ์ง ์์์!
A: ๋ค์ ์ฌํญ์ ํ์ธํด๋ณด์ธ์:
- ๋ณด์ ํจ์๊ฐ ์ ๋๋ก ์ค๊ณ๋์๋์ง ํ์ธ (๋๋ฌด ํฌ๋ฐํ์ง ์์์ง)
- ๊ด์ธก ์ ๋ณด๊ฐ ์ถฉ๋ถํ์ง ํ์ธ
- ํ์ต๋ฅ ์ด ์ ์ ํ์ง ํ์ธ (๋๋ฌด ๋๊ฑฐ๋ ๋ฎ์ ์ ์์)
- ํ๊ฒฝ์ด ๋๋ฌด ์ด๋ ต์ง ์์์ง ํ์ธ (์ฒ์์๋ ๊ฐ๋จํ ๋ฒ์ ์ผ๋ก ์์)
Q: ํ๋ จ๋ ๋ชจ๋ธ์ ๊ฒ์์ ์ด๋ป๊ฒ ์ ์ฉํ๋์?
A: ํ๋ จ์ด ์๋ฃ๋๋ฉด results ํด๋์ .onnx ํ์ผ์ด ์์ฑ๋ฉ๋๋ค. ์ด ํ์ผ์ Unity ํ๋ก์ ํธ๋ก ๊ฐ์ ธ์์ Behavior Parameters ์ปดํฌ๋ํธ์ Model ํ๋์ ์ฐ๊ฒฐํ๊ณ , Behavior Type์ 'Inference Only'๋ก ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
Q: ์ฌ๋ฌ ์์ด์ ํธ๊ฐ ํ๋ ฅํ๋๋ก ๋ง๋ค ์ ์๋์?
A: ๋ค! ML-Agents๋ ๋ฉํฐ์์ด์ ํธ ํ๊ฒฝ์ ์ง์ํฉ๋๋ค. ์ฌ๋ฌ ์์ด์ ํธ๊ฐ ๊ฐ์ ์ ์ฑ ์ ๊ณต์ ํ๊ฑฐ๋, ์๋ก ๋ค๋ฅธ ์ ์ฑ ์ ๊ฐ์ง ์ ์์ต๋๋ค. ํ๋ ฅ ํ์ต์ ์ํด์๋ ํ ๋ณด์์ ์ค๊ณํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๋ง๋ฌด๋ฆฌ: ์ฌ๋ฌ๋ถ์ AI ๊ฒ์ ๊ฐ๋ฐ ์ฌ์ ์ด ์์๋์ด์! ๐
์ง๊ธ๊น์ง Unity ML-Agents๋ฅผ ํ์ฉํด AI ๊ฒ์ ์บ๋ฆญํฐ๋ฅผ ํ๋ จ์ํค๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ดค์ด์. ์ฒ์์๋ ์ด๋ ค์ ๋ณด์ผ ์ ์์ง๋ง, ํ๋์ฉ ๋ฐ๋ผํ๋ค ๋ณด๋ฉด ์๊ฐ๋ณด๋ค ์ฝ๊ฒ ์ ๊ทผํ ์ ์๋ต๋๋ค! ใ ใ ใ
ML-Agents๋ ๊ฒ์ ๊ฐ๋ฐ์ ์๋ก์ด ์งํ์ ์ด์ด์ฃผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ์ ๋๋ค. ๋จ์ํ ๊ท์น ๊ธฐ๋ฐ AI๋ฅผ ๋์ด, ์ค์ ๋ก ํ์ตํ๊ณ ์ ์ํ๋ ์ง๋ฅํ ์บ๋ฆญํฐ๋ฅผ ๋ง๋ค ์ ์๊ฒ ํด์ฃผ์ฃ !
์ด ๊ธฐ์ ์ ๋ง์คํฐํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒ๋ค์ด ๊ฐ๋ฅํด์ง๋๋ค:
- ๋ ์์ฐ์ค๋ฝ๊ณ ๋์ ์ ์ธ NPC ํ๋ ํจํด ๊ตฌํ
- ํ๋ ์ด์ด ์คํ์ผ์ ์ ์ํ๋ ๋์ ๋์ด๋ ์กฐ์
- ์ ์ฐจ์ ์ฝํ ์ธ ์์ฑ๊ณผ ๊ฒฐํฉํ ๋ฌดํํ ๊ฒ์ ๊ฒฝํ
- ๊ฒ์ ํ ์คํธ ์๋ํ ๋ฐ ๋ฐธ๋ฐ์ฑ ์ต์ ํ
์ฌ๋ฅ๋ท์์๋ ์ด๋ฐ ์ต์ ๊ฒ์ ๊ฐ๋ฐ ๊ธฐ์ ์ ๊ดํ ๋ค์ํ ์ฌ๋ฅ์ ์ฐพ์๋ณผ ์ ์์ด์. ์ฌ๋ฌ๋ถ์ด ML-Agents๋ก ๋ง๋ ๋ ํนํ AI ์์คํ ์ด๋ ๊ฒ์ ๋ฉ์ปค๋์ฆ์ ๊ณต์ ํ๊ฑฐ๋, ๋ค๋ฅธ ๊ฐ๋ฐ์์ ๋ ธํ์ฐ๋ฅผ ๋ฐฐ์ธ ์ ์๋ ์ข์ ํ๋ซํผ์ด์ฃ ! ๐ก
์ฌ๋ฌ๋ถ์ ์ฒซ ๋ฒ์งธ AI ๊ฒ์ ์บ๋ฆญํฐ๋ ์ด๋ค ๋ชจ์ต์ผ๊น์? ์์๋ ฅ์ ๋ฐํํด์ ๋ ํนํ ํ์ต ํ๊ฒฝ์ ๋ง๋ค์ด๋ณด์ธ์! ๊ทธ๋ฆฌ๊ณ ๊ทธ ๊ณผ์ ์์ ๊ถ๊ธํ ์ ์ด ์๋ค๋ฉด ์ธ์ ๋ ์ง๋ฌธํด์ฃผ์ธ์. ํจ๊ป ์ฑ์ฅํ๋ ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ๊ฐ ์ฌ๋ฌ๋ถ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ต๋๋ค! ๐
๊ทธ๋ผ ์ด์ Unity๋ฅผ ์ผ๊ณ ML-Agents์ ์ธ๊ณ๋ก ๋ฐ์ด๋ค ์ค๋น๊ฐ ๋๋์? Let's go~! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.