• 2667번

  #include <iostream>
  #include <string>
  #include <vector>
  #include <algorithm>
  using namespace std;
  

#define MAX 26 string map[MAX]; int n; int cnt = 0; int dx[4] = { -1, 1, 0, 0 }; int dy[4] = { 0, 0,-1,1 }; vector v;

void dfs(int x, int y) { map[x][y] = '0'; cnt++; for (int i = 0; i < 4; i++) { int nx = x + dx[i]; int ny = y + dy[i]; if (nx >= 0 && nx < n && ny >= 0 && ny < n) { if (map[nx][ny] == '1') { dfs(nx, ny); } } } }

int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> map[i]; }

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        if (map[i][j] == '1') {
            dfs(i, j);
            v.push_back(cnt);
            cnt = 0;
        }
    }
}
cout << v.size() << "\n";
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
    cout << v[i] << "\n";
}

}

> 💡 string으로 받아오므로 문자와 비교하기

- [1012번](https://www.acmicpc.net/problem/1012)

#include #include <string.h> using namespace std;

#define MAX 51

int map[MAX][MAX] = { 0, }; bool visited[MAX][MAX] = { false, }; int T, M, N, K; //int n; int cnt = 0; int dx[4] = { -1, 1, 0, 0 }; int dy[4] = { 0, 0,-1,1 };

void dfs(int x, int y) { visited[x][y] = true; //cnt++; for (int i = 0; i < 4; i++) { int nx = x + dx[i]; int ny = y + dy[i]; if (nx >= 0 && nx < N && ny >= 0 && ny < M) { if (map[nx][ny] == 1 && !visited[nx][ny]) { dfs(nx, ny); } } } }

int main() { cin >> T; while (T > 0) { cnt = 0; cin >> M >> N >> K; for (int i = 0; i < K; i++) { int a, b; cin >> a >> b; map[b][a] = 1; } for (int i = 0; i < N; i++) { for (int j = 0; j < M; j++) { if (map[i][j] == 1 && !visited[i][j]) { dfs(i, j); cnt++;

            }
        }
    }
    cout << cnt << "\n";
    T--;
    memset(visited, false, sizeof(visited));
    memset(map, 0, sizeof(map));
}

}

> 💡 memset
배열 초기화를 위해 씀, memset(배열이름, 초기화할 값, 사이즈)

#include <string.h>

를 써주어야 한다.

• 1712번

  #include <iostream>
  using namespace std;
  
  

int main() { int a, b, c; cin >> a >> b >> c; if (b < c) { cout << a / (c - b) + 1; } else { cout << "-1"; }

}

- [10872번](https://www.acmicpc.net/problem/10872)

#include using namespace std; int fac(int n) { if (n <= 1) { return 1; } else { return n * fac(n - 1); } }

int main() { int m; cin >> m; cout << fac(m); }

- [10870번](https://www.acmicpc.net/problem/10870)

#include using namespace std; int fibo(int n) { if (n == 0) { return 0; } else if (n == 1) { return 1; } else { return fibo(n - 1) + fibo(n - 2); } }

int main() { int m; cin >> m; cout << fibo(m); }

- [11047번](https://www.acmicpc.net/problem/11047)

#include #include using namespace std; int coin[10]; int main() { int N, K; cin >> N >> K; int ans = 0; //vector coin(N); for (int i = 0; i < N; i++) { cin >> coin[i]; } for (int i = N - 1; K > 0;) { if (coin[i] > K) { i--; } else { K -= coin[i]; ans++; } } cout << ans; }

- [1931번](https://www.acmicpc.net/problem/1931)

#include #include #include using namespace std;

int main() { int N, start, end; cin >> N; vector<pair<int, int>> meeting; for (int i = 0; i < N; i++) { cin >> start >> end; meeting.push_back(make_pair(end, start)); } sort(meeting.begin(), meeting.end());

int time = meeting[0].first;
//cout << time;
int cnt = 1;
for (int i = 1; i < N; i++) {
    if (time <= meeting[i].second) {
        cnt++;
        time = meeting[i].first;
    }
}
cout << cnt;

}

- [11399번](https://www.acmicpc.net/problem/11399)

#include #include #include using namespace std;

int main() { int N, k,ans=0; cin >> N; vector line;

for (int i = 0; i < N; i++) {
    cin >> k;
    line.push_back(k);
}
sort(line.begin(), line.end());

for (int i = 0; i < N; i++) {
    ans += line[i] * (N - i);
}
cout << ans;

}

- [1541번](https://www.acmicpc.net/problem/1541)

#include #include using namespace std;

int main() { string str, tmp =""; int ans = 0; bool minus = false; cin >> str; for (int i = 0; i < str.size()+1; i++) { //cout << "str : " << str[i] << "\n"; if (str[i] == '+' || str[i] == '-' || str[i] == '\0') { if (minus) { ans -= stoi(tmp); } else { ans += stoi(tmp); } if (str[i] == '-') { minus = true; } tmp = ""; //cout << "ans : " << ans << "\n"; } else { tmp += str[i];

    }
}
cout << ans;

}

- [13305번](https://www.acmicpc.net/problem/13305)

#include using namespace std;

long long city[100001]; long long price[100001];

int main() { int N; long long ans =0; cin >> N;

for (int i = 0; i < N-1; i++) {
    cin >> city[i];
    //cout << city[i];
}
for (int i = 0; i < N; i++) {
    cin >> price[i];
}
int m = price[0];
for (int i = 0; i < N - 1; i++) {
    if (price[i] < m) {
        m = price[i];
    }
    ans += (long long)m * city[i];
}
cout << ans;

}

> 💡 int로 하면 범위 초과하기 때문에 long long으로 쓸 것 

- [1260번](https://www.acmicpc.net/problem/1260)

#include #include using namespace std; #define MAX 1001

int n, m, v; int map[MAX][MAX]; bool visited[MAX]; queue q;

void reset() { for (int i = 0; i <= n; i++) { visited[i] = false; } }

void DFS(int v) { visited[v] = true; cout << v << " ";

for (int i = 0; i <= n; i++) {
    if (map[v][i] == 1 && visited[i] == false) {
        DFS(i);
    }
}

}

void BFS(int v) { q.push(v); visited[v] = true;

while (!q.empty()) {
    v = q.front();
    q.pop();
    cout << v << " ";
    for (int i = 1; i <= n; i++) {
        if (map[v][i] == 1 && visited[i] == false) {
            q.push(i);
            visited[i] = true;
            //cout << i << " ";
        }
    }
}

}

int main() { cin >> n >> m >> v; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; map[a][b] = 1; map[b][a] = 1; }

reset();
DFS(v);

cout << "\n";

reset();
BFS(v);

}

- [2606번](https://www.acmicpc.net/problem/2606)
1. bfs

#include #include #define MAX 101 using namespace std; int n, m; int map[MAX][MAX] = { 0, }; bool visited[MAX] = { 0, }; queue q; int cnt = 0;

void bfs(int v) { q.push(v); visited[v] = true; while (!q.empty()) { v = q.front(); q.pop(); //cout << v << " "; for (int i = 1; i <= n; i++) { if (map[v][i] == 1 && visited[i] == false) { q.push(i); visited[i] = true; cnt++; } } } cout << cnt; }

int main() { //cout << visited[2]; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; map[a][b] = 1; map[b][a] = 1; } bfs(1); }

2. dfs

#include #define MAX 101 using namespace std; int n, m; int map[MAX][MAX] = { 0, }; bool visited[MAX] = { 0, }; int cnt = 0;

void dfs(int v) { visited[v] = true; cnt++; //cout << v << " "; for (int i = 0; i <= n; i++) { if (map[v][i] == 1 && visited[i] == false) { dfs(i); } } } int main() { //cout << visited[2]; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; map[a][b] = 1; map[b][a] = 1; } dfs(1); cout << cnt-1; } ```

• 2739번

  #include <iostream>
  using namespace std;
  

int main() { int N; cin >> N; for (int i = 1; i < 10; i++){ cout << N << " * " << i << " = " << N*i << "\n"; } }

> 💡 "\n"; 까먹지 말기!!

- [10950번](https://www.acmicpc.net/problem/10950)

#include using namespace std;

int main() { int T; cin >> T; int A, B; for (int i = 0; i < T; i++){ cin >> A >> B; cout << A + B << "\n"; } }

- [8393번](https://www.acmicpc.net/problem/8393)

#include using namespace std;

int main() { int N; cin >> N; int sum = 0; for (int i = 0; i < N+1; i++){ sum += i; } cout << sum << "\n"; }

- [15552번](https://www.acmicpc.net/problem/15552)

코드를 입력하세요

- [2741번](https://www.acmicpc.net/problem/2741)

#include using namespace std;

int main() { int N; cin >> N; for (int i = 1; i < N+1; i++){ cout << i << "\n"; }

}

- [11021번](https://www.acmicpc.net/problem/11021)

#include using namespace std;

int main() { int T; cin >> T; int A, B; for (int i = 1; i < T + 1; i++){ cin >> A >> B; cout << "Case #" << i << ": " << A+B << "\n"; }

}

- [10951번](https://www.acmicpc.net/problem/10951)

#include using namespace std;

int main() { int A , B; while (cin >> A >> B){ cout << A+B << "\n"; }

}

백준 단계별 학습 - 입출력과 사칙연산, if문 문제를 통해 C++을 처음부터 다시 복습하였다.

• 2757번

  #include <iostream>
  using namespace std;
  int main(){
    cout<<"Hello World!"<< "\n";
    return 0;
  }

  📌 "\n" endl를 써도 되지만 빠른 입출력을 요구하는 경우 endl 지양

• "\n"역할 + 내부 버퍼 비우기

• 10718번

  #include <iostream>
  using namespace std;
  

int main(){ cout << "강한친구 대한육군"<< "\n"; cout << "강한친구 대한육군"; }

- [1008번](https://www.acmicpc.net/problem/1008)

#include using namespace std;

int main(){ double A,B; cin >> A >> B; cout.precision(12); cout << fixed; cout << A/B; }

> 📌 cout.precision(n)
소수점 자릿수 조절

cout.precision(n)

-> n자리 나타내준다.
ex) n = 7 , 123.456689 -> 123.4567 , 89는 반올림 된다.

cout << fixed; cout.precision(n)

-> 소수점 이하의 자릿수만 다룰 수 있다. 소수점 이하의 n개의 수 나타낸다.
ex) n = 7 , 123.45668915 -> 123.4566892 , 5는 반올림 된다.

cout.unsetf(ios::fixed);

cout << fixed; 해제 

- [10869번](https://www.acmicpc.net/problem/10869)

#include using namespace std;

int main(){ int A,B; cin >> A >> B; cout << A+B << "\n"; cout << A-B << "\n"; cout << A*B << "\n"; cout << A/B << "\n"; cout << A%B; }

> 이 문제의 경우 int로 출력 나오므로 int로 변수 선언하기

- [10430번](https://www.acmicpc.net/problem/10430)

#include using namespace std;

int main(){ int A,B,C; cin >> A >> B >> C; cout << (A+B)%C << "\n"; cout << ((A%C) + (B%C))%C << "\n"; cout << (A*B)%C << "\n"; cout << ((A%C) * (B%C))%C ;

}

- [2588번](https://www.acmicpc.net/problem/2588)
방법1. 수학적 계산

#include using namespace std;

int main(){ int A,B; cin >> A >> B; cout << A * (B%10) << "\n"; cout << A * ((B%100)/10) << "\n"; cout << A * (B/100) << "\n"; cout << A * B; }

방법2. string이용

#include #include using namespace std;

int main(){ int A; string B; cin >> A >> B; cout << A * (B[2] - '0') << "\n"; cout << A * (B[1] - '0') << "\n"; cout << A * (B[0] - '0') << "\n"; cout << A * stoi(B); }

> char n[] = "123";
int num = n[0]; ==> num = 49 , 문자 '1'이 저장되어 아스키 코드의 '1'에 해당되는 49가 저장된다. 따라서 인덱스를 참조한 뒤 -'0'을 통해 '0'에 해당되는 48을 빼주어 1로 사용하기 위함이다.

> 📌 stoi()

#include

-> string, stoi()을 사용하기 위한 헤더파일
stoi() 
==> string -> int(10진수)

- [1330번](https://www.acmicpc.net/problem/1330)

#include using namespace std;

int main() { int a, b; cin >> a >> b; if (a < b) { cout << "<"; } else if(a == b) { cout << "=="; } else { cout << ">"; }

}

- [2753번](https://www.acmicpc.net/problem/2753)

#include using namespace std;

int main() { int a; cin >> a; if ((a % 4 == 0 && a % 100 != 0)|| a % 400 == 0){ cout << "1"; } else{ cout << "0"; }

}

- [2884번](https://www.acmicpc.net/problem/2884)

#include using namespace std;

int main() { int H, M; cin >> H >> M; if (M < 45){ M += 15; if (--H < 0) H = 23; } else M -= 45; cout << H << " " << M; }

## 2. 알고리즘 연습 (python)
- [14496번](https://www.acmicpc.net/problem/14496)

sudo apt-get update
sudo apt-get install -y python-wstool python-rosdep ninja-build stow

폴더 생성, 소스 다운

mkdir carto_ws && cd carto_ws && wstool init src

wstool merge -t src https://raw.githubusercontent.com/cartographer-project/cartographer_Ros/master/cartographer_ros.rosinstall

wstool update -t src

dependency 설치

rosdep update
rosdep install --from-path src --ignore-src --rosdistro=${ROS_DISTRO} -y

abseil 설치

src/cartographer/scripts/install_abseil.sh 

user환경 적용, 설치

sudo su - 
source /home/jw/bashrc 
cd /home/jw/carto_ws/
catkin_make_isolated --install --use-ninja --install-space /opt/ros/melodic

import sys
n, a, d = map(int, sys.stdin.readline().split())
t = list(map(int, sys.stdin.readline().split()))
x = 0

for i in range(n):
    if t[i] == a + (x*d):
        x += 1
print(x)

import sys
n = int(sys.stdin.readline())
t = list(map(int, sys.stdin.readline().split()))
t.sort()
#print(t)
if n % 2 == 0:
    M = 0
    for i in range(n//2):
        M = max(t[i]+t[n-i-1], M)
        #print(i)
else:
    M = t[n-1]
    for i in range(n // 2):
        M = max(t[i] + t[n - i - 2], M)
        #print(i)
print(M)

• 0~9로 이루어진 손글씨 숫자 데이터
• 28x28 흑백
• 60000개 학습 데이터, 10000개 테스트 데이터 => pytorch 이용해 MNIST 데이터 분류 ANN 네트워크 구현

이미지 = batch X 28 X 28 X 1 (흑백이기 때문) --> 벡터 : batch X 28 * 28 = batch x 784

인공신경망 연산 -> linear layer, 3

출력 = batch x 10 (0-9 각각에 대한 확률이기 때문)

코드

import torch
import torch.nn as nn # 딥러닝 네트워크 구현 및 학습을 간단하게 수행할 수 있도록 다양한 함수 제공
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms 
# datasets = 다양한 데이터셋 제[공
# tranforms = 데이터 전처리 등 수행

import numpy as np

# GPU 있는 경우 pytorch 연산을 gpu로, 그렇지 않은 경우 cpu로 수행
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 파라미터 설정
batch_size = 128 # 한번 학습시 128개의 데이터를 통해 학습
num_epochs = 10 # 모든 데이터에 대해 10번 학습 수행

learning_rate = 0.00025 # 학습률 (학습 속도 결정 -> 너무 작으면 학습 속도가 느립, 값 크면 최적 x)


# MNIST 데이터 다운로드
trn_dataset = datasets.MNIST('./mnist_data/', download=True, train=True, transform=transforms.Compose([transforms.ToTensor()]))
val_dataset = datasets.MNIST('./mnist_data/', download=False, train=False, transform=transforms.Compose([transforms.ToTensor()]))

# 다운로드 경로,
# download = True 인 경우 데이터셋 다운 받음, 이미 다운 받아진 경우 다운 진행 x
# train -> True 인 경우 학습 데이터로 사용, False 인 경우 학습 데이터로 사용 x
# pytorch 텐서의 형태로 데이터 출력 -> pytorch 연산의 경우ㅠ tensor 형태로 연산 진행

# DataLoader 설정
trn_loader = torch.utils.data.DataLoader(trn_dataset, batch_size=batch_size, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=True)

# ANN 네트워크
class ANNClassifier(nn.Module):
    def __init__(self):
        super(ANNClassifier, self).__init__() #  항상 torch.nn.Module을 상속받고 시작
        self.fc1 = nn.Linear(28*28,256) ## 28*28 = 입력 데이터의 크기 (28*28 이미지)
        self.fc2 = nn.Linear(256,64)
        self.fc3 = nn.Linear(64,10)

        self.drop = nn.Dropout(p=0.2) # 20% 노드의 출력을 0으로 도출

    # 이미지 데이터의 구조 변환 (batch x 28 x 28 x 1) -> (batch x 28*28)
    def forward(self, x):
        x = x.view(x.size(0), -1)  # 선형 연산 수행 후 비선형 함수(relu) 통과
        x = F.relu(self.fc1(x))
        x = self.drop(x) # dropout 수행

        x = F.relu(self.fc2(x))
        x = self.drop(x)

        # 선형 연산만 수행
        x = self.fc3(x)
        return F.softmax(x, dim=1) # 최종 결과에 softmax 연산 수행
        # softmax : 출력 결과를 확률로 변환 (합 = 1), 입력에 대한 결과의 확률을 알 수 있음

# 정확도를 도출하는 함수
# y = 네트워크 연산 결과, label = 실제 결과
# label은 현재 입력이 어떤 숫자인지의 값을 보여준다.(batch size x 1)
# y는 각 숫자에 대한 확률을 나타낸다. (batch size x 10)
def get_accuracy(y, label):
    y_idx = torch.argmax(y, dim=1)
    # argmax = 확률 중 가장 큰 값의 인덱스를 반환하여 label과 동일한 형식으로 변환

    # 모든 입력에 대해 정답을 맞춘 개수를 전체 개수로 나눠주어 정확도 반환
    result = y_idx-label

    num_correct = 0
    for i in range(len(result)):
        if result[i] == 0:
            num_correct += 1
    return num_correct/y.shape[0]

# 네트워크, 손실함수, 최적화기 선언
ann = ANNClassifier().to(device)  # 네크워크 정의, 설정한 device에서 딥러닝 네트워크 연산을 하도록 설정
criterion = nn.CrossEntropyLoss() # 손실함수 설정, 분류 문제에서 많이 사용
optimizer = optim.Adam(ann.parameters(), lr=learning_rate) 

num_batches = len(trn_loader) # 한 epoch에 대한 전체 미니배치의 수

# 학습 수행
for epoch in range(num_epochs):
    # 학습시 손실함수 값과 정확도 ㄱㅣ록하기 위한 리스트
    trn_loss_list = [] 
    trn_acc_list = []
    # 1epoch연산을 ㄷ위한 반복문 
    # 여기서 data는 각 배치로 나누어진 데이터와 정답을 포함
    for i, data in enumerate(trn_loader):
        # 데이터 처리
        ann.train() #네트워크 학습을 위한 모드로 설정

        # 학습데이터 (x: 입력, label: 정답)를 받아온 후 device에 올려줌
        x, label = data
        x = x.to(device)
        label = label.to(device)

        # 네트워크 연산 및 손실함수 계산
        model_output = ann(x) # 네트워크 연산 수행 후 출력값 도출 (입력 : x, 출력 : model_output)
        loss = criterion(model_output, label) # 손실함수 값 계산 -> 네트워크 연사ㅓㄴ 결과를 연산하여 손실함수 값 도출

        # 네트워크 업데이트
        optimizer.zero_grad() # 학습 수행 전 미분값을 0으로 초기화 (학습 전 꼭 수행 !!!!)
        loss.backward() # 네트워크 변수(가중치 w, 편향 b)에 대한 기울기가 계산
        optimizer.step() # 네트워크 변수 업데이트

        # 학습 정확도 및 손실함수 값 기록
        # 네트워크의 연산 결과와 실제 정답 결과를 비교하여 정확도를 도출
        trn_acc = get_accuracy(model_output, label)

        # 손실함수 값을 trn_loss_list 추가 (item : 하나의 값으로 된 tensor를 일반 값으로 바꿔줌)
        trn_loss_list.append(loss.item()) 
        # 정확도 값을 trn_acc_list에 추가
        trn_acc_list.append(trn_acc)

        # 학습 진행 상황 출력 및 검증셋 연산 수행
        if (i+1) % 100 == 0: # 매 100번째 미니배치 연산마다 진행상황 출력
            ann.eval() # 네트워크를 검증 모드로 설정
            with torch.no_grad(): # 학습에 사용하지 않는 코드들은 해당 블록 내에 기입
                # 검증시 손실함수 값과 정확도를 저장하기 위한 리스트
                val_loss_list = []
                val_acc_list = []

                for j, val in enumerate(val_loader):
                    val_x, val_label = val

                    val_x = val_x.to(device)
                    val_label = val_label.to(device)

                    val_output = ann(val_x)

                    val_loss = criterion(val_output, val_label)
                    val_acc = get_accuracy(val_output, val_label)

                    val_loss_list.append(val_loss.item())
                    val_acc_list.append(val_acc)
                print("epoch: {}/{} | step: {}/{} | trn loss: {:.4f} | val loss: {:.4f} | trn acc: {:.4f} | val acc: {:.4f}".format(
                  epoch+1, num_epochs, i+1, num_batches, np.mean(trn_loss_list), np.mean(val_loss_list), np.mean(trn_acc_list), np.mean(val_acc_list)
                ))

결과

batch_size 변경

batch_size : 128 -> 10

-> 학습정확도와 검증 정확도 모두 올랐다. 대신 한 번의 epoch를 오래 진행한다.

batch_size : 128 -> 250

학습 정확도와 검증 정확도 모두 줄었다. 대신 학습이 빨리 진행된다.

learning_rate 변경

learning_rate : 0.0025 ->  0.05

값이 커져서 정확도가 매우 떨어진다.

learning_rate : 0.0025 ->  0.0001

정확도도 살짝 떨어지고, 학습 시간은 비슷하다.

learning_rate : 0.0025 ->  0.00001

정확도가 많이 떨어진다.

dropout 변경

dropout : 0.2 -> 0.7

드롭아웃을 너무 많이 실행하면 없어지는 값이 많아서인지 정확도가 떨어진다.

dropout : 0.2 -> 0.05

드롭아웃을 조금 실행하면 기존보다는 적지만 overfitting을 조금 줄이는 결과를 가져와 정확도가 오르는 것 같다.

num_epochs 변경

num_epochs : 10 -> 3 

너무 학습을 적게 해서 underfitting 되었을 것 같다.

num_epochs : 10 -> 15 

학습 정확도와 검증 정확도 모두 올랐다.

pytorch를 이용한 간단한 네트워크 연산 수행

• 3개의 입력 (랜덤), 2개 출력
• 은닉층 2 ( 4개의 processing unit)

# 라이브러리 불러오기
import torch
import torch.nn as nn # 딥러닝 네트워크 구현 및 학습을 간단하게 수행할 수 있도록 다양한 함수 제공
import torch.nn.functional as F

# GPU 있는 경우 pytorch 연산을 gpu로, 그렇지 않은 경우 cpu로 수행
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 딥러닝 모델
class Model(nn.Module):
    # 네트워크 변수 정의
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(3,4) ## nn.Linear = 선형 연산 (Wx+ b)
        self.fc2 = nn.Linear(4,4)
        self.fc3 = nn.Linear(4,2)

    #네트워크 구조 결정 및 연산 수행    
    def forward(self, x):
        # 선형 연산 수행 후 비선형 함수 통과 
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        # 선형 연산만 수행
        x = self.fc3(x)
        return x

 # 네트워크 선언
 # Model 클래스 호출 후 연산 장치를 할당하고 model로 선언한다.
model = Model().to(device)

# Pytourch를 이용한 연산 수행
# 입력데이터를 생성한다. (2,3) 랜덤 데이터를 torch로 생성 후 연산 장치를 할당한다.
x = torch.rand(2,3).to(device)
# 딥러닝 모델에 입력 x를 대입하여 결과값을 도출한다. (model의 forward함수 연산)
output = model(x)

# 결과 출력
print(output)

# 결과값을 numpy 변환 
# cpu -> 연산장치 cpu로 변환
# detach -> gradient 전파 안되도록 함, 이를 수행하면 해당 텐서값은 딥러닝 학습 수행에 사용 x, numpy과정을 위해 꼭 수행해야 한다.
# numpy -> tensor를 numpy로 변환
output_np = output.cpu().detach().numpy()
print(output_np)

결과 ->

코드 중

def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(3,4) ## nn.Linear = 선형 연산 (Wx+ b)

->

self.fc2 = nn.Linear(4,4)
self.fc3 = nn.Linear(4,2)

이 부분은 각각 이 부분들을 나타낸다.

• Artificial Neural Network (ANN)
• Convolutional Neural Network (CNN)
• Recurrent Neural Network (RNN)

Deep Q Network (DQN)

• Q-Learning
• Deep Q Network
• Deep Q Network 확장 기법

Deep Deterministic Policy Gradient (DDPG)

AI & ML & DL

AI (Artificial Intelligence)

• 인간의 학습능력과 추론능력, 지각능력, 자연언어의 이해 능력 등 컴퓨터 프로그램으로 실현한 기술

ML (Machine Learning)

• 인간의 학습능력과 같은 기능을 컴퓨터에서 실현하고자 하는 기술 및 기법
• "학습", 데이터 기반으로 알고리즘이 스스로 학습

DL (Deep Learning)

• 다층 구조 형태 신경망, 다양의 데이터로부터 높은 수준의 추상화 모델을 구축하고자 하는 기법

ML 학습방법

지도 학습

• 정답이 있는 데이터 이용
• 분류문제, 회귀문제

비지도 학습

• 정답 모름, 데이터 특징만을 이용하여 학습
• 클러스터링

강화 학습

• 보상을 통해 학습 수행
• 행동을 통한 명확한 보상을 줄 수 있는 곳, 게임 등

Deep Learning

• 알고리즘, GPU(큰 행렬 연산을 위해), Big Data(많은 데이터 -> 좋은 학습)의 발전으로 같이 발전
• 손 글씨 인식, 표지판 인식, 텍스트 생성 등

ANN

• 사람의 뇌와 유사한 방법으로 정보 처리

• 뉴런을 모밥한 기본 단위 집합으로 구성

• 원하는 값 학습 -> 가중히 w, 편향 b 학습하는 것

• 가중치 학습하는 것 중 가장 많이 사용하는 ReLU y = x if x >=0 y = 0 if x < 0

• 입력층, 은닉층, 출력층 -> forward Propagation 결과와 이미 알고 있는 Target값과 비교 <- BackPropagation (은닉층에 가중치들 학습 실행하게 된다)

  => 정답과 유사하게 학습

• 이때, 출력값과 정답을 비교할때 사용하는 것 : loss 학습 => loss 함수를 최소화 하도록 weight, bias를 학습하는 것이 목표!!

• Underfitting : 학습이 부족하여 제대로 된 예측 수행 x Good fitting : 적절하게 학습 수행 Overfitting : 과도하게 학습이 수행, training set에 대해서는 좋은 예측이지만 처음 보는 데이터에는 나쁜 성능

• Dropout -> overfitting 방지하는 기법 중 하나, 특정 확률에 따라 뉴런을 0으로 만들어서 네트워크에 변화 줌

ANN 문제점

• input이 살짝만 바껴도 다른 input으로 인식한다.
• 모든 데이터 대응하기 위해 많은 데이터 필요
• 학습 시간 많이 걸리고 성능도 제한적

풀이

n = list(input())
n.insert(0,'N')
#print(n)
count = 0
for i in range(1,len(n)):
    if n[i] == 'Y':
        for j in range(i,len(n), i):
            if n[j] == 'Y':
                n[j] = 'N'
            else:
                n[j] = 'Y'
        count += 1
print(count)

pub-8.py

#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Twist

rospy.init_node('my_node', anonymous=True)
pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

msg = Twist()
msg.linear.x = 2.0
msg.linear.y = 0.0
msg.linear.z = 0.0
msg.angular.x = 0.0
msg.angular.y = 0.0


rate = rospy.Rate(1)

while not rospy.is_shutdown():
    for _ in range(2):
        msg.angular.z = 4.0
        pub.publish(msg)
        rate.sleep()
    for _ in range(2):
        msg.angular.z = -4.0
        pub.publish(msg)
        rate.sleep()

pub-sub-8.launch

<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node" /> 
    <node pkg="my_pkg1" type="pub-8.py" name="pub_node" /> 
    <node pkg="my_pkg1" type="sub.py" name="sub_node" output="screen" /> 
</launch>

실행

roslaunch my_pkg1 pub-sub-8.launch 

애매하지만 8자로 주행하긴 한다!

pub-sub-param.launch

<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node" /> 
    <node pkg="my_pkg1" type="pub-param.py" name="pub_node" > 
        <param name="circle_size" value="2" />
    </node>
    <node pkg="my_pkg1" type="sub.py" name="sub_node" output="screen" /> 
</launch>

==> circle_size = 2

pub-param.py

#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Twist

rospy.init_node('my_node', anonymous=True)
pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

msg = Twist()
#msg.linear.x = 2.0
linear_X=rospy.get_param('~circle_size')
msg.linear.x = linear_X
msg.linear.y = 0.0
msg.linear.z = 0.0
msg.angular.x = 0.0
msg.angular.y = 0.0
msg.angular.z = 1.8

rate = rospy.Rate(1)

while not rospy.is_shutdown():
    pub.publish(msg)
    rate.sleep()

==> param 이용할 때는 '~'으로 사용하기

실행

roslaunch my_pkg1 pub-sub-param.launch

param 변경, pub-sub-param.launch

<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node" /> 
    <node pkg="my_pkg1" type="pub-param.py" name="pub_node" > 
        <param name="circle_size" value="4" />
    </node>
    <node pkg="my_pkg1" type="sub.py" name="sub_node" output="screen" /> 
</launch>

==> circle_size = 4

거북이 원으로 돌기

xycar_ws/src 밑에 my_pkg1을 만든다. xycar_ws/src/my_pkg1 밑에 launch 폴더를 만든다.

pub.py

#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Twist

rospy.init_node('my_node', anonymous=True)
pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

msg = Twist()
msg.linear.x = 2.0
msg.linear.y = 0.0
msg.linear.z = 0.0
msg.angular.x = 0.0
msg.angular.y = 0.0
msg.angular.z = 1.8

rate = rospy.Rate(1)

while not rospy.is_shutdown():
    pub.publish(msg)
    rate.sleep()

코드 설명

#!/usr/bin/env python

파이썬을 사용할 것을 알린다.

import rospy
from geometry_msgs.msg import Twist

필요한 것들 import geometry_msgs/Twist

rospy.init_node('my_node', anonymous=True)
pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

my_node라는 노드를 만들고 , Publisher객체 생성 (Twist 타입의 /turtle1/cmd_vel 이름으로 토픽을 만들며 Publisher임을 알린다. )

msg = Twist()
msg.linear.x = 2.0
msg.linear.y = 0.0
msg.linear.z = 0.0
msg.angular.x = 0.0
msg.angular.y = 0.0
msg.angular.z = 1.8

Twist객체에 6개의 숫자들 넣는다.

rate = rospy.Rate(1)

1초에 한 번 발행을 위함

while not rospy.is_shutdown():
    pub.publish(msg)
    rate.sleep()

위에 6개의 숫자들 토픽을 publish하고, 1초에 한 번 발행을 위해 그 시간에 맞추어 쉬어간다.

실행

실행권한을 준다.

chmod +x pub.py

터미널 1

roscore

터미널 2

rosrun turtlesim turtlesim_node

터미널 3

rosrun my_pkg1 pub.py

터미널 4

rqt_graph

-> 이때, my_node 뒤에 숫자는

rospy.init_node('my_node', anonymous=True)

에서 anonymous=True 옵션때문이다.

거북이 원으로 돌기 출력

sub.py

#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Pose

def callback(data):
    s = "location: %.2f, %.2f" % (data.x, data.y)
    rospy.loginfo(rospy.get_caller_id() + s)

rospy.init_node('my_listener', anonymous=True)
rospy.Subscriber('/turtle1/pose', Pose, callback)
rospy.spin()

코드 설명

#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Pose

파이썬 사용하고 관련 된 것 import

def callback(data):
    s = "location: %.2f, %.2f" % (data.x, data.y)
    rospy.loginfo(rospy.get_caller_id() + s)

data.x, data.y와 id를 loginfo해서 출력

rospy.init_node('my_listener', anonymous=True)
rospy.Subscriber('/turtle1/pose', Pose, callback)
rospy.spin()

my_listener이름으로 노드 생성 Pose 타입 /turtle1/pose 이라는 토픽이름으로 Subscriber임을 알린다.

이때, 메시지를 수신하면 callback 함수 호출 이것을 반복한다.

실행

실행권한을 준다.

chmod +x sub.py

터미널 1

roscore

터미널 2

rosrun turtlesim turtlesim_node

터미널 3

rosrun my_pkg1 pub.py

터미널 4

rosrun my_pkg1 sub.py

터미널 5

rqt_graph

launch 이용

실행

<node pkg="패키지 명" type="노드 포함 소스파일 명" name="노드 이름" /> 

launch 같이 실행

<include file="같이 실행할 *.launch 파일 경로" />
ex 1 ) <include file="../이름.launch" />
ex 2 ) <include file="$(find pkg)/src/launch/이름.launch" />

ros 파라미터 서버에 변수 등록, 변수 값 설정

<param name="변수 이름" type="변수 타입" value="변수 값" />

pub-sub.launch

<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node" /> 
    <node pkg="my_pkg1" type="pub.py" name="pub_node" /> 
    <node pkg="my_pkg1" type="sub.py" name="sub_node" output="screen" /> 
</launch>

실행

roslaunch my_pkg1 pub-sub.launch 

https://visualstudio.microsoft.com/ko/vs/ Community 2019 다운

2. opencv 설치

https://opencv.org/releases/page/2/

3. 설정

3.1 visual studio 확인

visual studio 에서 hello world! 출력 후, visual studio가 잘 동작하는 것을 확인한다.

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
}

3.2 구성 관리자

빌드 - 구성관리자 활성 솔루션 플랫폼을 x64로 바꿔준다.

3.3 속성

프로젝트 - 속성

3.3.1 추가 포함 디렉터리

속성 - c/c++ - 일반 - 추가 포함 디렉터리

opencv 다운 받은경로 \ build \ include 와 opencv 다운 받은경로 \ build \ include \ opencv2 를 추가해준다. ex) C:\opencv\build\include\opencv2 C:\opencv\build\include

3.3.2 추가 라이브러리 디렉터리

속성 - 링커 - 일반 - 추가 라이브러리 디렉터리

opencv 다운 받은경로 \ build \ x64 \ vc15 \ lib

3.3.3 추가 종속성

C:\opencv\build\x64\vc15\lib 밑에 두 가지가 있는데 지금은 디버깅으로 설정했으므로 opencv_world430d.lib를 복사한다. 그 후 추가 종속성에 추가한다.

4.확인

이때 opencv.hpp 는 C:\opencv\build\include\opencv2 에 있으며 이것을 include 하면 다른 헤더파일도 포함된다.

#include <iostream>
#include <opencv.hpp>

using namespace cv;
int main()
{
    Mat img = imread("lenna.jpg");
    imshow("lenna.jpg", img);
    waitKey(0);
    destroyAllWindows();
}

💡 lenna.jpg 는 구글에서 쉽게 구할 수 있다. 프로젝트 폴더안에 넣어야 한다. (소스코드 있는 곳)

+) 5. 안 될 경우

--> 이때 솔루션 빌드를 하고 디버거를 누르면 실행이 되어야 하는데

opencv_world430d.dll이 없다는 오류가 나온다.

--> 환경변수 설정 시스템 변수 - Path 에 opencv 설치 경로 \ build\x64\vc15\bin ex) C:\opencv\build\x64\vc15\bin

를 추가한다.

https://www.python.org/downloads/release/python-370/

2. pygame 설치

윈도우 cmd에서 C:\ 로 이동

pip install pygame==1.9.6

3. pillow 설치

pip install pillow

-> 버전 지정해줄 필요 없다.

4. numpy 설치

https://pypi.org/project/numpy/#files 에서 numpy-1.20.3-cp37-cp37m-win_amd64.whl을 다운 받는다.

python -m pip install .\numpy-1.20.3-cp37-cp37m-win_amd64.whl

5. visual studio 설치

https://visualstudio.microsoft.com/ko/vs/ Community 2019 다운

• C++를 사용한 데스크톱 개발
• MSVC v141 -VS 2017 C++ x64/x84 빌드... 선택

국민대 자율주행 대회 준비

• 예선 과제 1,2,3 문서 작성 ==> 문서 작성 깔끔하게, 그림 깔끔하게 ppt에서 선택해서 그림으로 저장

K-Digital-Training: 자율주행 데브코스

• 3D 자동차 구동 제어 과제
• 센서장치 기초, IMU 활용
• 라이다 활용

==> 밀리지 말기, 과제 왜 안되는지 다시 해보기 ==> imu활용 과제, 라이다 활용 과제도 내일 시도

노트북에 실습 필요한 내용 설치 (vm, ubuntu, ros, ..)

• 의존성 문제 계속 나온다

==> 인터넷에서 찾은 명령어들 다 실행해본 것 같은데 안 된다😥 ==> 내일 다시 도전!!

** TIL도 꾸준히!!!

• 화면 크기, 파일 복사, 클립 보드 등 여러가지 설정 가능

  sudo apt install open-vm-tools{,-desktop}

  

설치 완료 후 재부팅

sudo reboot

2. 데일리 서비스 비활성화

apt-daily.timer apt-daily-upgrade.timer 비활성화

sudo systemctl disable --now apt-daily.timer
sudo systemctl disable --now apt-daily-upgrade.timer

확인하기

 sudo systemctl status apt-daily.timer
 sudo systemctl status apt-daily-upgrade.timer

-> disabled/ inactive 임을 확인

3. 폰트 설치

sudo apt -y install fonts-nanum* fonts-naver*

터미널 - 편집 - 기본설정 - 프로파일

4. 설정

4.1) 키보드 설정 설정 - 지역 및 언어 한국어 (Hangul)만 남기기

4.2) 자동 화면 잠금 설정- 개인 정보 설정- 전원 빈화면

설치

1. vmware
2. Ubuntu 18.04.5 http://mirror.kakao.com/ubuntu-releases/18.04.5/ubuntu-18.04.5-desktop-amd64.iso

vmware 설치

-> disabled 하기

-> Create a New Virtual Machine 선택

-> 파일이 만들어 지는 위치 -> 넉넉하게 잡기 -> edit virtual machine settings 선택

-> 처음에 받은 kakao iso 위치를 선택해준다.