์๋ ํ์ธ์๐GDGoC member ์ด๊ฐํ ์ ๋๋ค.
์ ๋ ๋ฅ๋ฌ๋ ํ๋ก์ ํธ์์ ํ์ต ๊ณผ์ ์ ์ง๊ด์ ์ผ๋ก ๋ชจ๋ํฐ๋งํ ์ ์๋ ๋๊ตฌ, TensorBoard์ ํ์ฉ๋ฒ์ ๋ํด ์๊ฐํด๋๋ฆฌ๋ ค ํฉ๋๋ค.
Tensorboard๋ฅผ ๋จผ์ ์๊ฐ ๋๋ฆฌ๊ณ , ๋ฅ๋ฌ๋์์ ์ฌ์ฉํ๋ ์์, ๋จธ์ ๋ฌ๋์์ ์ฌ์ฉํ ์ ์๋ ์์๋ฅผ ์๊ฐํด๋๋ฆฌ๋๋ก ํ๊ฒ ์ต๋๋ค !
TensorBoard ๋?
Tensorflow๊ฐ ์ ๊ณตํ๋ ํ์ต ๊ณผ์ ์๊ฐํ ๋๊ตฌ๋ก, ํ์ต ์ค์ ๋ฐ์ํ๋ Loss, Accuracy, Gradient ๋ฑ์ ๋ค์ํ ๋ก๊ทธ๋ฅผ
์ค์๊ฐ์ผ๋ก ๊ทธ๋ํ ํํ๋ก ํ์ธํ ์ ์๋๋ก ๋ณด์ฌ์ค๋๋ค.
ํ์ต ์งํ๋ค์ ๊ทธ๋ํ๋ก ํ์ธ ํ๋ฉด์, ํ์ต์ด ์ ๋๋ก ์ด๋ฃจ์ด์ง๊ณ ์๋์ง ํ์ธํ ์ ์๊ณ ,
ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ ํ, ์ด์ ๊ฒฐ๊ณผ์ ๋น๊ตํจ์ผ๋ก์จ ํจ๊ณผ์ ์ธ ์ค์ ์กฐํฉ์ ํ์ํ๋๋ฐ ๋์์ ์ค๋๋ค.
๋, ๋ชจ๋ธ ๊ตฌ์กฐ ๋ฐ ๋ด๋ถ ์ ๋ณด๋ฅผ ๋ถ์ํ ์ ์์ด, ํ๋ผ๋ฏธํฐ์ ๋ถํฌ์ ๋ณํ, gradient ๋ณํ๋ฅผ ์ถ์ ํ ์ ์์ต๋๋ค.
๋ํ ์ฐ์ฐ ๊ทธ๋ํ๋ฅผ ์๊ฐํ ํจ์ผ๋ก์จ ๋ชจ๋ธ ๊ตฌ์กฐ๋ฅผ ํ์ ํ ์๋ ์์ต๋๋ค.
ํนํ, ์์ฆ ์ด๋ฏธ์ง, ์์ฑ, ํ ์คํธ ๋ฑ ๊ณ ์ฐจ์ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํ ๋ชจ๋ธ๋ค์ด ๋ค์ํ๊ฒ ๊ฐ๋ฐ ๋๊ณ ์๋๋ฐ์.
Tensorboard์์ ๊ณ ์ฐจ์ ๋ฐ์ดํฐ ๋ํ ๊ณ ์ฐจ์ ์๋ฒ ๋ฉ์ ํตํด ๋ฐ์ดํฐ ๊ฐ ๊ด๊ณ๋ฅผ ์๊ฐํ ํ ์ ์๊ณ ,
์ด๋ฅผ ์ด์ฉํ ์์ธก ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋กํ ์๋ ์์ต๋๋ค.


PyTorch์ TensorBoard ์ฐ๋ ์ค์ต - ๋ฅ๋ฌ๋
์ ๋ ๊ฐ๋จํ๊ฒ titanic ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์จ ๋ค์ ๊ฐ๋จํ ๋ชจ๋ธ์ ์ ์ํ์ฌ, ์ค์ต ์งํํ์ต๋๋ค.
๋ฐ์ดํฐ ์
X = df.drop("Survived", axis=1).values
y = df["Survived"].values
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
class TitanicDataset(Dataset):
def __init__(self, X, y):
self.X = torch.tensor(X, dtype=torch.float32)
self.y = torch.tensor(y, dtype=torch.long)
def __len__(self): return len(self.X)
def __getitem__(self, idx): return self.X[idx], self.y[idx]
train_loader = DataLoader(TitanicDataset(X_train, y_train), batch_size=32, shuffle=True)
test_loader = DataLoader(TitanicDataset(X_test, y_test), batch_size=32)
๋ชจ๋ธ ์ ์
class TitanicNet(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(6, 16),
nn.ReLU(),
nn.Linear(16, 2)
)
def forward(self, x): return self.net(x)
model = TitanicNet().to(device)
SummaryWriter ์ค์
: summaryWriter ์์ ๋ก๊ทธ๊ฐ ์ ์ฅ๋ ๋๋ ํ ๋ฆฌ ๊ฒฝ๋ก๋ฅผ ์ง์ ํ์ฌ, writer์ ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
writer = SummaryWriter("runs/nn_titanic")
๋ก๊ทธ ๊ธฐ๋ก
: ํ์ต ์ฝ๋ ๋ด๋ถ์ writer.add_scalar()๋ฅผ ์ถ๊ฐํ์ฌ, ์ํ๋ ๋ก๊ทธ๋ฅผ ๊ธฐ๋กํ๋๋ก ์ค์ ํฉ๋๋ค.
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(100):
model.train()
total_loss = 0
correct = 0
for X_batch, y_batch in train_loader:
X_batch, y_batch = X_batch.to(device), y_batch.to(device)
output = model(X_batch)
loss = criterion(output, y_batch)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
pred = output.argmax(1)
correct += (pred == y_batch).sum().item()
acc = correct / len(train_loader.dataset)
# writer๋ก ๋ก๊ทธ ๊ธฐ๋ก
writer.add_scalar("Loss/train", total_loss / len(train_loader), epoch)
writer.add_scalar("Accuracy/train", acc, epoch)
Writer close
: ๋ก๊ทธ ์ฐ๋๊ฒ์ ์ข ๋ฃํ๊ธฐ ์ํด ํ์ต์ด ๋๋ ํ, ์๋์ ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
writer.close()
Tensorboard ์คํ
: ๋ก๊ทธ๋ฅผ ํ์ธํ ์ ์๋๋ก ์๋์ ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ฉ๋๋ค!
%load_ext tensorboard
%tensorboard --logdir=runs
์คํํ๋ฉด, ์ด๋ฐ์์ผ๋ก ํ์ธํ ์ ์์ต๋๋ค!

LGBM๊ณผ TensorBoard ์ฐ๋ ์ค์ต - ๋จธ์ ๋ฌ๋
์ด๋ฒ ์ค์ต์์๋ titanic ๋ฐ์ดํฐ์ ์ ๋ถ๋ฌ์จ ๋ค์ ๋จธ์ ๋ฌ๋์ LightCBM ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์์ธกํ ์ ์๋๋ก ์งํํ์์ต๋๋ค.
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์์๋ ํ์ต ๋ก๊ทธ ๊ธฐ๋ก์ด ์ ์ ๋ก ๋์ด๊ฐ์ง ์์ง๋ง ๋ก๊ทธ ๊ธฐ๋ก์ ๊ตฌํํ์ฌ ๋์ผํ๊ฒ ์๊ฐํํ ์ ์์ต๋๋ค!
๋ฐ์ดํฐ ์
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_test, label=y_test)
SummaryWriter ์ค์
: summaryWriter ์์ ๋ก๊ทธ๊ฐ ์ ์ฅ๋ ๋๋ ํ ๋ฆฌ ๊ฒฝ๋ก๋ฅผ ์ง์ ํ์ฌ, writer์ ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
writer = SummaryWriter("runs/nn_titanic")
๋ก๊ทธ ๊ธฐ๋ก์ ์ํ ์ฝ๋ฐฑ ํจ์ ์ ์
def tb_callback(env):
epoch = env.iteration
train_loss = env.evaluation_result_list[0][2]
val_loss = env.evaluation_result_list[1][2]
writer.add_scalar("Loss/train", train_loss, epoch)
writer.add_scalar("Loss/valid", val_loss, epoch)
๋ชจ๋ธ ์ ์
: ๋ชจ๋ธ train ์ฝ๋ ์์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฃ์ด, ๋ก๊ทธ ๊ธฐ๋ก์ ๊ฐ๋ฅํ ๋ก ํฉ๋๋ค.
## ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ
params = {
"objective": "binary",
"metric": "binary_logloss",
"learning_rate": 0.1,
"verbosity": -1
}
model = lgb.train(
params,
train_data,
num_boost_round=100,
valid_sets=[train_data, valid_data],
valid_names=["train", "valid"],
## ์ฝ๋ฐฑ
callbacks=[
tb_callback,
lgb.log_evaluation(period=1)
]
)
predict ๋ก๊ทธ ๊ธฐ๋ก
: ์์ธกํ ๊ฒฐ๊ณผ๋ก ๋์จ ๋ก๊ทธ๋ฅผ ๊ธฐ๋กํ๊ณ ์ ํ ๋, model.predict ํ, ๊ธฐ๋กํ๋๋ก ํ๋ฉด, test ๊ฒฐ๊ณผ๋ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค!
y_pred = model.predict(X_test)
acc = accuracy_score(y_test, (y_pred >= 0.5).astype(int))
writer.add_scalar("Accuracy/test", acc, 0)
Writer close
: ๋ก๊ทธ ์ฐ๋๊ฒ์ ์ข ๋ฃํ๊ธฐ ์ํด ํ์ต์ด ๋๋ ํ, ์๋์ ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
writer.close()
Tensorboard ์คํ
: ๋ก๊ทธ๋ฅผ ํ์ธํ ์ ์๋๋ก ์๋์ ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ฉ๋๋ค!
%load_ext tensorboard
%tensorboard --logdir=runs
์คํํ๋ฉด, ์ด๋ฐ์์ผ๋ก ํ์ธํ ์ ์์ต๋๋ค!

Tensorboard๋ฅผ ์ ์ด์ฉํ๋ค๋ฉด ๋ชจ๋ธ์ ์ฑ๋ฅ์ ๋น ๋ฅด๊ฒ ๊ฐ์ ํ๊ณ ,
์คํ์ ๋ฐ๋ณตํ๋ฉด์ ์ ํํ ๋ฐฉํฅ์ผ๋ก ๋์๊ฐ ์ ์๊ฒ ๋์์ ์ฃผ๋ ์ข์ ๋๊ตฌ์ ๋๋ค!
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ๊ตฌํํ๊ฑฐ๋ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ๊ตฌํํ ๋, ํ์ฉํ์ฌ ์ข์ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋ค์ด๋ณด์ธ์๐๐ถ
๊ฐ์ฌํฉ๋๋ค๐
'๋์๋ฆฌ,ํํ > GDGoC' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [AI ์คํฐ๋] Section 12 : YOLO ๋ชจ๋ธ Fast API๋ก ๋ฐฐํฌ (3) | 2024.12.27 |
|---|---|
| [AI ์คํฐ๋] Section 11 : GAN (Generative Adversarial Network) (1) | 2024.12.27 |
| [AI ์คํฐ๋] Section 10 : Autoencoder (1) | 2024.12.27 |
| [AI ์คํฐ๋] Section 9 : RNN (3) | 2024.12.27 |
| [AI ์คํฐ๋] Section 8 : ์ ์ดํ์ต (2) | 2024.12.27 |