ecosso 님의 블로그

[골목길 탐지하기]_종로구 정사영상 기준 실험 (2/2)

ecosso — Thu, 6 Aug 2026 17:31:16 +0900

최근 진행 중인 프로젝트의 일부로, 공개 도로 데이터를 보완할 수 있는 방법을 고민하다가 간단한 토이 프로젝트를 진행하고 있었다.

[골목길 탐지하기]_종로구 정사영상 기준 실험 (1/2)

이전 실험에서는 기존 공개 도로데이터를 학습 라벨로 활용하여 정사영상에서 도로를 탐지하고자 했다. 그러나 실험을 반복하면서 모델 구조를 변경하는 것만으로 해결하기 어려운 문제가 있다는 점을 확인했다.

특히 기존 도로데이터에는 실제 보행에 이용되는 일부 골목길이 포함되어 있지 않았고, 도로 중심선을 일정한 폭으로 확장하여 만든 라벨 역시 실제 영상에서 보이는 도로 경계와 정확하게 일치하지 않았다.

결국 모델에게 더 복잡한 구조를 적용하기 전에 학습에 사용하는 정답 데이터부터 다시 확인할 필요가 있다고 판단했다.

[직접 제작(디지타이징)한 라벨 사용]

이전 과정에서는 표준도로링크와 토지피복도로부터 제작한 중심선 + 2m 버퍼 등 여러 데이터를 이용하여 학습 라벨을 구성해 보았다.

하지만 위에서 기술한 것처럼 골목길을 탐지하는 것이 목적임에도 정작 학습에 사용하는 도로데이터에 일부 골목길이 존재하지 않는다는 문제가 있었다. 또한 영상의 공간해상도가 충분하지 않은 경우 좁은 도로와 주변 객체의 경계를 구분하기 어려웠다.

이에 일부 지역의 도로를 직접 디지타이징하여 학습 라벨을 다시 구축하였다. 즉, 원하는 수준까지의 도로 및 도로폭까지 모두 제작을 진행하였다.

이 과정에서 모델 구조뿐만 아니라 입력 영상의 품질과 학습 라벨의 정확도 역시 탐지 결과에 중요한 영향을 미칠 수 있다는 점을 확인할 수 있었다.

[하나의 모델이 아니라 세 가지 모델을 비교한 이유]

라벨을 보완한 이후에는 하나의 모델로만 학습·추론을 진행하지 않고, 서로 다른 구조를 가진 세 가지 Semantic Segmentation 모델을 동일한 데이터 조건에서 비교하기로 하였다.

세 모델을 비교하게 된 계기는 초기 U-Net 추론 결과에서 확인한 도로의 단절 문제였다.

항공정사영상에서는 도로 위를 덮고 있는 수목이나 건물에 의해 생긴 그림자 때문에 실제로는 하나의 도로임에도 일부 구간의 형태와 색상이 크게 달라지는 경우가 있었다. 특히 수목이 우거진 구간에서는 도로가 가려지면서 모델의 예측 결과가 중간에서 끊기고, 가려진 구간 이후부터 다시 새로운 도로가 시작되는 것처럼 탐지되는 사례가 나타났다.

실제 도로는 연속적인 구조를 가지고 있지만, 수목이나 그림자 등으로 도로의 시각적 특징이 크게 달라지는 구간에서는 모델이 가려진 구간의 앞뒤를 하나의 연속된 도로로 충분히 복원하지 못하는 사례가 나타났다.

여기서 한 가지 질문이 생겼다. :

도로처럼 길고 연속적인 구조를 가진 객체를 탐지할 때, 더 넓은 주변 영역과의 관계를 고려하는 모델을 사용하면 결과가 달라질까?

이 질문을 바탕으로 기존에 사용하던 U-Net을 기준 모델로 두고, 보다 넓은 범위의 공간적·문맥적 정보를 활용할 수 있는 구조를 추가로 비교하였다.

U-Net
Encoder-Decoder 구조와 Skip Connection을 사용하는 대표적인 Semantic Segmentation 모델이다. 기존 실험에서 사용했던 모델이므로 비교를 위한 기준 모델(Baseline)로 설정하였다.
D-LinkNet
LinkNet 계열의 Encoder-Decoder 구조에 Dilated Convolution을 활용하여, 특징맵의 해상도를 추가로 크게 낮추지 않으면서 넓은 수용영역(Receptive Field)을 확보할 수 있다. 도로처럼 가늘고 길게 이어지는 객체의 segmentation에 활용된 모델이라는 점에서, 주변 문맥을 보다 넓게 고려했을 때 단절된 도로 탐지 결과가 달라지는지 확인하기 위해 선택하였다.
SegFormer-B0
CNN 중심의 앞선 두 모델과 달리 Transformer 기반 Encoder를 사용하여 CNN과 다른 방식으로 공간적 특징과 문맥 정보를 학습하는 모델이다. CNN 기반 모델과 다른 방식으로 주변 정보를 활용했을 때 도로 탐지 결과에 어떤 차이가 나타나는지 비교하기 위해 선택하였다.

세 모델을 동일한 학습 데이터와 조건에서 학습한 뒤, 모델별로 설정한 임계값을 적용하여 종로구 내 2개 격자분에 해당하는 정사영상에 추론하였다.

이번 단계에서는 단순히 특정 평가지표가 가장 높은 모델을 선정하기보다, 수목이나 그림자 등에 의해 도로의 시각적 특징이 부분적으로 달라지는 상황에서, 서로 다른 방식으로 주변 문맥을 학습하는 모델들이 연속적인 도로 구조를 어떻게 탐지하는지 비교하는 것에 초점을 두었다.

Model	Threshold	도로 폴리곤 수	중심선 수
U-Net	0.700	10,431	36,114
D-LinkNet	0.625	16,652	65,815
SegFormer-B0	0.625	47,294	89,404

▲ U-Net 적용

▲ D-Linknet 적용

▲ SegFormer-B0 적용

종로구 내 2개 격자의 항공영상에 적용한 결과, 모델에 따라 추출되는 도로 영역의 양과 형태에 상당한 차이가 나타났다.

U-Net은 세 모델 가운데 가장 적은 수의 도로 폴리곤과 중심선을 생성하여 상대적으로 보수적인 탐지 양상을 보였다. D-LinkNet은 U-Net보다 많은 도로 영역과 중심선을 추출했으며, SegFormer-B0은 47,294개의 폴리곤과 89,404개의 중심선을 생성하여 가장 많은 영역을 도로로 탐지하였다.

다만 생성된 폴리곤이나 중심선의 개수만으로 탐지 성능의 우열을 판단할 수는 없다는 것을 알 수 있었다. 기존 도로데이터에서 누락된 협소도로를 추가로 탐지하여 개수가 증가할 수도 있지만, 반대로 비도로 영역을 잘못 탐지하거나 하나의 도로가 여러 조각으로 분절되면서 개수가 증가할 수도 있기 때문이다.

실제 결과를 함께 확인했을 때 SegFormer-B0에서는 다른 두 모델보다 탐지 영역이 크게 증가하는 한편, 비도로 영역까지 도로로 판단하거나 결과가 잘게 분절되는 사례도 상대적으로 많이 관찰되었다. 반면 U-Net은 비교적 보수적인 탐지 결과를 보였으며, D-LinkNet은 두 모델의 중간적인 양상을 나타냈다.

이 결과를 통해 도로 탐지 모델을 평가할 때에는 탐지 영역의 양뿐만 아니라 실제 공간에서 나타나는 도로의 연속성, 단절, 누락, 오탐 및 불필요한 가지와 같은 공간적 특성도 함께 확인할 필요가 있다고 판단하였다.

특히 이번 프로젝트의 최종 목적은 탐지된 도로를 중심선으로 변환하여 보행 네트워크 분석에 활용하는 것이므로, 최종 모델 선정 역시 단순한 탐지량보다는 실제 도로망과의 정합성 및 네트워크 연결성을 추가로 검증한 뒤 결정할 필요가 있다.

따라서 현재 단계에서는 특정 모델을 최종 모델로 확정하기보다, 서로 다른 구조의 모델이 동일한 영상에서도 상당히 다른 공간적 결과를 생성한다는 점을 확인한 비교 실험으로 정리하였다.

[반복 실험을 위한 CUDA 환경 구축]

이번 실험에서 또 하나의 문제는 연산시간이었다.

초기에는 별도의 GPU가 없는 학원 컴퓨터에서 모델을 학습했는데, 한 번의 학습에 약 7~9시간이 소요될 것으로 예상되었다. 학습이 진행되는 동안에는 컴퓨터를 다른 용도로 활용하기도 어려웠다.

처음에는 이러한 제약을 해결하기 위해 여러 컴퓨터에 지역별 학습을 분산하고, 각 지역에서 학습한 모델을 활용하는 방법도 검토하였다. 그러나 사용할 수 있는 컴퓨터가 제한적이었고 일부 장비는 정상적으로 활용하기 어려웠다. 무엇보다 한 번의 실험에 반나절 가까운 시간이 필요한 상황에서는 여러 조건을 바꾸어가며 결과를 반복적으로 확인하는 것 자체가 쉽지 않았다.

Semantic Segmentation 실험에서는 한 번 모델을 학습하는 것으로 끝나는 것이 아니라 결과를 확인한 뒤,

학습 → 결과 확인 → 문제 추정 → 데이터·라벨·모델 조정 → 재학습

위의 과정을 반복해야 했다.

예를 들어 결과가 좋지 않다면 학습 라벨의 품질이 원인인지, 입력 영상의 문제인지, 모델 구조나 학습 조건의 문제인지를 확인하기 위해 다시 실험해야 한다. 그러나 한 번의 결과를 확인하는 데 7~9시간이 걸린다면 몇 가지 가설을 검증하는 데만 며칠이 필요하고, 이후 서울시 여러 지역으로 실험을 확장하는 것은 현실적으로 더 큰 시간적 제약이 될 수밖에 없었다.

따라서 단순히 모델의 성능을 높이는 것뿐만 아니라 실험 한 번에 필요한 시간을 줄여 반복적인 검증이 가능한 환경을 만드는 것 자체가 먼저 해결해야 할 문제라고 판단하였다.

관련 논문과 딥러닝 학습 사례를 찾아보는 과정에서 NVIDIA GPU의 병렬연산을 활용하는 CUDA에 대해 알게 되었고, 개인 컴퓨터에 NVIDIA GPU가 탑재되어 있다는 점을 활용하여 PyTorch·CUDA 기반 GPU 학습환경을 직접 구축하였다.

이를 통해 대용량 정사영상과 여러 모델을 반복적으로 학습·추론할 수 있는 환경을 마련하였고, 동일한 조건에서 U-Net, D-LinkNet, SegFormer-B0의 결과를 비교하는 실험도 보다 현실적으로 수행할 수 있게 되었다.

이번 경험에서 CUDA 자체를 사용하는 것이 목적은 아니었다. 오히려 의미가 있었던 부분은 한정된 인프라와 시간 안에서 더 많은 가설을 검증하기 위해 실험환경 자체를 개선했다는 점이었다.

모델 개발에서는 정확도뿐만 아니라 데이터 규모, 연산시간, 메모리, 사용 가능한 하드웨어와 같은 현실적인 제약 역시 실험 설계의 일부이며, 빠르게 결과를 확인하고 다음 실험으로 이어갈 수 있는 환경을 만드는 것 또한 모델 개선 과정의 중요한 요소라는 점을 경험할 수 있었다.

[이번 실험에서 확인한 것]

이번 프로젝트를 진행하면서 가장 크게 느낀 점은 모델의 성능은 모델 구조 하나만으로 결정되지 않는다는 것이었다.

초기 실험에서는 기대했던 만큼 협소도로를 탐지하지 못했지만, 원인을 확인하는 과정에서 모델뿐만 아니라 영상의 공간해상도와 학습 라벨의 품질이 결과에 큰 영향을 미친다는 점을 확인하였다. 이에 더 높은 해상도의 영상을 확보하고 일부 지역의 라벨을 직접 구축하여 학습 데이터를 개선하였다.

이후에는 수목이나 그림자 등에 의해 실제로는 연속된 도로가 중간에서 끊겨 탐지되는 문제에 주목하였다. 이를 바탕으로 주변 문맥을 서로 다른 방식으로 학습하는 모델에서는 결과가 달라지는지 확인하기 위해 U-Net, D-LinkNet, SegFormer-B0을 동일한 조건에서 비교하였다. 종로구 영상에 적용한 결과 모델별로 탐지 영역의 양과 분절 양상이 상당히 다르게 나타났으며, 이를 통해 탐지량뿐만 아니라 실제 도로의 연속성, 누락, 오탐과 같은 공간적 특성을 함께 검토할 필요가 있다고 판단하였다.

반복적인 학습과 비교 과정에서는 연산시간 자체가 실험의 병목이 되기도 했다. 이를 해결하기 위해 PyTorch·CUDA 기반 GPU 환경을 구축하면서, 분석에서는 모델과 데이터뿐만 아니라 제한된 시간과 연산자원 안에서 반복적인 실험이 가능한 환경을 만드는 것도 중요하다는 점을 경험하였다.

물론 아직 한계는 남아 있다. 건물이나 그림자 등 도로와 유사한 영역을 잘못 탐지하거나 일부 협소도로를 놓치는 사례가 있으며, 현재 종로구를 중심으로 한 실험 결과만으로 특정 모델이 다른 지역에서도 가장 우수하다고 일반화하기는 어렵다. 따라서 향후에는 다른 지역에서도 모델의 성능과 탐지 양상이 유지되는지 추가적인 검증이 필요하다.

이번 프로젝트에서는 다음의 과정을 하나의 흐름으로 직접 수행하였다.

공간데이터와 영상데이터의 전처리 및 정합
학습 라벨 구축과 품질 검토
서로 다른 Semantic Segmentation 모델의 학습·비교
GPU 기반 반복 학습·추론 환경 구축
종로구 내 영상에 대한 모델별 추론 결과 비교
예측 Mask의 Polygon·Centerline 변환 및 후속 공간분석 연결

이번 프로젝트의 가장 큰 수확은 단순히 ‘도로를 얼마나 잘 찾았는가’라는 최종 성능보다, 결과가 기대와 다를 때 하나의 원인으로 단정하지 않고 데이터, 라벨, 모델, 학습환경을 차례로 점검하며 다음 실험을 설계해 본 경험이었다.

[골목길 탐지하기]_종로구 정사영상 기준 실험 (1/2)

ecosso — Fri, 31 Jul 2026 17:32:30 +0900

공공데이터로 제공받을 수 있는 도로가 실제 이동 가능한 모든 길을 포함하는 것은 아니다. 도로를 어느 기준까지 포함하여 작도할지는 각 자료가 제작된 목적에 따라 달라질 수도 있기 때문이다.

특히 주거지 내부의 골목길과 생활도로는 기존 도로 자료에서 누락되는 경우가 있으며, 이로 인해 보행 경로 분석에서는 실제보다 긴 우회 경로가 계산될 수 있다.

따라서 국토정보플랫폼에서 제공하는 정사영상을, 데이터는 표준노드링크의 링크 데이터를 사용하여 서울특별시 내 보행 가능한 골목길을 탐지하는 과제를 진행해보기로 했다.

우선 분석 전에 서울특별시 전체의 정사영상은 약 110~120GB 정도로 예상되는 상황이었으며, 무작정 분석을 돌리기엔 학원 PC의 사양이 문제가 되었다. 또한 시간적인 문제도 매우 큰 관계로 학습 시간을 단축하기 위해 CUDA 기반 GPU 연산을 검토하였다. 그러나 당시 사용한 학원 PC에는 CUDA를 지원하는 NVIDIA GPU가 설치되어 있지 않아 CPU만으로 학습을 진행해야 하는 상황이었다.

또한 영상 패치를 여러 연산 장치에 분산하는 과정에서 도로의 경계와 연속성이 충분히 유지되는지 우려되어 강사님께 해당 방법에 대한 문의를 진행하였다.

이 과정에서 여러 대의 PC를 활용하여 서울시 자치구별 학습을 분담하는 방안도 검토하였다. 우선 1개 구 분량의 데이터로 학습한 U-Net 모델을 기준 모델로 저장한 뒤, 동일한 모델을 각 PC에 배포하고 서로 다른 자치구의 정사영상으로 추가 학습하는 방식이다. 이후 자치구별 모델을 통합하고 서울시 전체 영상으로 다시 미세조정하는 방안을 구상하였다.

다만 서로 다른 데이터로 독립적으로 학습된 신경망의 가중치를 단순 평균하는 방식은 항상 안정적인 성능을 보장하지 않는다. 따라서 실제 적용 시에는 자치구별 학습 데이터를 순차적으로 사용하여 하나의 모델을 추가 학습하거나, 전체 데이터를 통합한 뒤 동일한 모델을 미세조정하는 방식과 비교 검증할 필요가 있다고 판단하였다.

따라서 베이스 모델을 위 종로구 정사영상을 이용한 최초 학습은 약 9시간이 소요될 것으로 예상되었다. 그러나 실행 중 Zoom과 QGIS 등 CPU와 메모리를 사용하는 프로그램이 함께 실행되고 있음을 확인하였다. 불필요한 프로그램을 종료한 후 전체 학습에는 약 7시간이 소요되었다.

▲ 표준노드링크의 링크 shp

▲ 표준링크를 이용한 학습/추출 결과

본 과제의 목표는 기존 표준노드링크에 포함되지 않은 생활도로와 골목길까지 정사영상으로부터 자동 추출하는 것이었다. 그러나 표준노드링크는 도로 외곽선(Line) 형태의 벡터 데이터이므로, U-Net과 같은 의미론적 분할 모델에서 요구하는 픽셀 단위의 도로 라벨로 직접 활용하기에는 한계가 있었다.

이에 따라 표준노드링크를 일정 폭의 Polygon으로 변환하여 도로 영역을 생성하고, Polygon 내부의 픽셀을 도로 클래스로 학습시키는 방식을 적용하였다.

이를 통해 모델이 단순히 링크의 위치를 기억하는 것이 아니라, 정사영상에서 나타나는 도로의 시각적 특성을 학습하여 표준링크에 존재하지 않는 미세도로까지 일반화할 수 있는지를 확인하고자 하였다.

초기 모델의 탐지 결과를 확인한 결과 표준노드링크가 구축된 간선도로와 광폭도로는 비교적 안정적으로 분할되었다. 도로 폭이 넓고 포장면이 연속적으로 나타나는 구간에서는 예측 경계도 실제 도로 형태와 대체로 유사하게 형성되었다.

반면, 주거지 내부의 골목길이나 건물 사이의 협소도로는 상당 부분 누락되었다. 이러한 구간은 도로 폭이 좁고 건물 그림자, 주차 차량, 보도 및 인접 지붕과의 경계가 복잡하여 영상만으로 도로의 시각적 특징을 구분하기 어려웠다. 또한 학습 라벨로 사용한 표준노드링크가 주로 주요 도로 중심으로 구축되어 있기에 미세도로에 대한 학습 정보가 충분하지 않았던 점도 원인으로 판단하였다.

즉, 초기 모델은 주요 도로를 탐지하는 데에는 일정 수준의 성능을 보였으나, 보행 네트워크 보완에 필요한 골목길과 생활도로까지 추출하기에는 한계가 있었다. 이에 따라 이후 단계에서는 미세도로를 보다 강하게 반영할 수 있는 추가 학습 라벨을 구축하고 모델을 미세조정할 필요가 있다고 판단하였다.

미세도로에 대한 학습 정보를 보완하기 위해, 다음 단계에서는 세분류 토지피복지도의 도로 클래스를 추가 학습 라벨로 활용하였다. 기존 표준노드링크 기반 학습에서 가장 우수한 성능을 보인 모델을 초기 모델로 불러온 뒤, 세분류 토지피복지도에서 도로로 분류된 영역을 정답 라벨로 사용하여 Fine-tuning을 수행하고자 하였다.

세분류 토지피복지도는 표준노드링크에 비해 골목길과 생활도로가 더 세밀하게 표현되어 있다는 장점이 있었다. 따라서 기존 모델이 충분히 학습하지 못했던 협소도로의 특징을 보완할 수 있을 것으로 기대하였다.

학습결과 (펼치기)

==============================================================================
세분류 토지피복도 도로 기반 U-Net 미세조정 시작
토지피복도 폴더: C:\Users\itwill\Desktop\세분류
도로 조건: L3_CODE=154
기존 모델: D:\Final\02_Output\Jongro_Ortho_Road_Segmentation_v3\04_road_unet.keras
출력 폴더: D:\Final\02_Output\Jongro_Landcover_Road_Finetune
==============================================================================

▶ 정사영상 모자이크 준비 시작 | RAM 1.19GB / 시스템 47%
기존 정사영상 모자이크 재사용: D:\Final\02_Output\Jongro_Ortho_Road_Segmentation_v3\01_jongro_orthomosaic_5179_050cm.tif
✓ 정사영상 모자이크 준비 완료: 0.0초 (0.00분) | RAM 1.19GB / 시스템 47%
PROJ DATA: C:\Users\itwill\anaconda3\Lib\site-packages\rasterio\proj_data
TensorFlow GPU: []
Mixed precision 비활성화
모자이크 CRS: EPSG:5179
모자이크 크기: 17,827 × 22,464
해상도: 0.500m × 0.500m

▶ 교차 도엽 도로 추출 시작 | RAM 1.19GB / 시스템 47%
세분류 SHP 전체 수: 139
정사영상과 교차하는 도엽 선별:   0%|          | 0/139 [00:00<?, ?file/s]
정사영상과 교차하는 SHP: 37개
 - 37608038.shp
 - 37608039.shp
 - 37608040.shp
 - 37608047.shp
 - 37608048.shp
 - 37608049.shp
 - 37608050.shp
 - 37608057.shp
 - 37608058.shp
 - 37608059.shp
 - 37608060.shp
 - 37608067.shp
 - 37608068.shp
 - 37608069.shp
 - 37608070.shp
 - 37608077.shp
 - 37608078.shp
 - 37608079.shp
 - 37608080.shp
 - 37608087.shp
 - 37608088.shp
 - 37608089.shp
 - 37608090.shp
 - 37705031.shp
 - 37705032.shp
 - 37705041.shp
 - 37705042.shp
 - 37705051.shp
 - 37705052.shp
 - 37705061.shp
 - 37705062.shp
 - 37705071.shp
 - 37705072.shp
 - 37705081.shp
 - 37705082.shp
 - 37608039.shp
 - 37608049.shp
L3_CODE=154 도로 추출:   0%|          | 0/37 [00:00<?, ?file/s]
추출된 도로 폴리곤 수: 6,546
도로 폴리곤 총면적: 27,134,246.3㎡
클립 도로 폴리곤 저장: D:\Final\02_Output\Jongro_Landcover_Road_Finetune\02_landcover_road_polygons_clipped.gpkg
✓ 교차 도엽 도로 추출 완료: 57.4초 (0.96분) | RAM 1.26GB / 시스템 47%

▶ 토지피복도 도로 마스크 rasterize 시작 | RAM 1.26GB / 시스템 47%
토지피복도 도로 rasterize:   0%|          | 0/6546 [00:00<?, ?geom/s]
✓ 토지피복도 도로 마스크 rasterize 완료: 39.2초 (0.65분) | RAM 1.66GB / 시스템 51%
학습 마스크 도로 픽셀: 117,473,400 (29.3342%)

▶ 밴드 정규화 통계 시작 | RAM 2.41GB / 시스템 56%
밴드별 2~98 percentile: [(0.0, 181.0), (0.0, 190.0), (0.0, 176.0)]
✓ 밴드 정규화 통계 완료: 9.6초 (0.16분) | RAM 2.81GB / 시스템 58%

▶ 학습·검증 패치 구성 시작 | RAM 2.81GB / 시스템 58%
학습 패치 좌표 검사:   0%|          | 0/24325 [00:00<?, ?patch/s]
양성 패치: 12,069
배경 패치 사용: 3,017
학습 좌표: 12,021
검증 좌표: 3,065
✓ 학습·검증 패치 구성 완료: 39.0초 (0.65분) | RAM 0.03GB / 시스템 46%

▶ 토지피복도 라벨 미세조정 학습 시작 | RAM 0.03GB / 시스템 46%
Epoch 1/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 521ms/step - accuracy: 0.7699 - dice_coefficient: 0.5082 - loss: 1.4282 - pr_auc: 0.6696 - precision: 0.6759 - recall: 0.4918 - roc_auc: 0.8087    
Epoch 1: val_dice_coefficient improved from None to 0.58338, saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras

Epoch 1: finished saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1687s 553ms/step - accuracy: 0.7699 - dice_coefficient: 0.5082 - loss: 1.4282 - pr_auc: 0.6696 - precision: 0.6759 - recall: 0.4918 - roc_auc: 0.8087 - val_accuracy: 0.7890 - val_dice_coefficient: 0.5834 - val_loss: 0.9397 - val_pr_auc: 0.7603 - val_precision: 0.7331 - val_recall: 0.5496 - val_roc_auc: 0.8708 - learning_rate: 1.0000e-05
Epoch 2/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 453ms/step - accuracy: 0.7801 - dice_coefficient: 0.5328 - loss: 1.2390 - pr_auc: 0.6980 - precision: 0.6768 - recall: 0.5533 - roc_auc: 0.8340   
Epoch 2: val_dice_coefficient did not improve from 0.58338
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1452s 483ms/step - accuracy: 0.7801 - dice_coefficient: 0.5328 - loss: 1.2390 - pr_auc: 0.6980 - precision: 0.6768 - recall: 0.5533 - roc_auc: 0.8340 - val_accuracy: 0.7903 - val_dice_coefficient: 0.5768 - val_loss: 0.9555 - val_pr_auc: 0.7686 - val_precision: 0.7598 - val_recall: 0.5171 - val_roc_auc: 0.8743 - learning_rate: 1.0000e-05
Epoch 3/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 455ms/step - accuracy: 0.7835 - dice_coefficient: 0.5449 - loss: 1.1693 - pr_auc: 0.7066 - precision: 0.6743 - recall: 0.5806 - roc_auc: 0.8419   
Epoch 3: val_dice_coefficient did not improve from 0.58338
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1463s 487ms/step - accuracy: 0.7835 - dice_coefficient: 0.5449 - loss: 1.1693 - pr_auc: 0.7066 - precision: 0.6743 - recall: 0.5806 - roc_auc: 0.8419 - val_accuracy: 0.7897 - val_dice_coefficient: 0.5722 - val_loss: 0.9127 - val_pr_auc: 0.7730 - val_precision: 0.7726 - val_recall: 0.4981 - val_roc_auc: 0.8788 - learning_rate: 1.0000e-05
Epoch 4/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 456ms/step - accuracy: 0.7862 - dice_coefficient: 0.5508 - loss: 1.1163 - pr_auc: 0.7161 - precision: 0.6705 - recall: 0.6071 - roc_auc: 0.8488   
Epoch 4: val_dice_coefficient did not improve from 0.58338
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1466s 488ms/step - accuracy: 0.7862 - dice_coefficient: 0.5508 - loss: 1.1163 - pr_auc: 0.7161 - precision: 0.6705 - recall: 0.6071 - roc_auc: 0.8488 - val_accuracy: 0.7941 - val_dice_coefficient: 0.5828 - val_loss: 0.8998 - val_pr_auc: 0.7763 - val_precision: 0.7618 - val_recall: 0.5312 - val_roc_auc: 0.8800 - learning_rate: 1.0000e-05
Epoch 5/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 448ms/step - accuracy: 0.7877 - dice_coefficient: 0.5562 - loss: 1.0712 - pr_auc: 0.7229 - precision: 0.6658 - recall: 0.6298 - roc_auc: 0.8537   
Epoch 5: val_dice_coefficient improved from 0.58338 to 0.58913, saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras

Epoch 5: finished saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1439s 479ms/step - accuracy: 0.7877 - dice_coefficient: 0.5562 - loss: 1.0712 - pr_auc: 0.7229 - precision: 0.6658 - recall: 0.6298 - roc_auc: 0.8537 - val_accuracy: 0.7952 - val_dice_coefficient: 0.5891 - val_loss: 0.8726 - val_pr_auc: 0.7779 - val_precision: 0.7566 - val_recall: 0.5434 - val_roc_auc: 0.8817 - learning_rate: 1.0000e-05
Epoch 6/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 447ms/step - accuracy: 0.7894 - dice_coefficient: 0.5641 - loss: 1.0364 - pr_auc: 0.7293 - precision: 0.6631 - recall: 0.6487 - roc_auc: 0.8578   
Epoch 6: val_dice_coefficient improved from 0.58913 to 0.59639, saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras

Epoch 6: finished saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1436s 478ms/step - accuracy: 0.7894 - dice_coefficient: 0.5641 - loss: 1.0364 - pr_auc: 0.7293 - precision: 0.6631 - recall: 0.6487 - roc_auc: 0.8578 - val_accuracy: 0.7982 - val_dice_coefficient: 0.5964 - val_loss: 0.8594 - val_pr_auc: 0.7822 - val_precision: 0.7525 - val_recall: 0.5631 - val_roc_auc: 0.8833 - learning_rate: 1.0000e-05
Epoch 7/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 446ms/step - accuracy: 0.7905 - dice_coefficient: 0.5653 - loss: 1.0219 - pr_auc: 0.7327 - precision: 0.6613 - recall: 0.6611 - roc_auc: 0.8603   
Epoch 7: val_dice_coefficient did not improve from 0.59639
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1431s 476ms/step - accuracy: 0.7905 - dice_coefficient: 0.5653 - loss: 1.0219 - pr_auc: 0.7327 - precision: 0.6613 - recall: 0.6611 - roc_auc: 0.8603 - val_accuracy: 0.7947 - val_dice_coefficient: 0.5857 - val_loss: 0.8802 - val_pr_auc: 0.7808 - val_precision: 0.7716 - val_recall: 0.5211 - val_roc_auc: 0.8828 - learning_rate: 1.0000e-05
Epoch 8/8
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 0s 447ms/step - accuracy: 0.7910 - dice_coefficient: 0.5638 - loss: 1.0079 - pr_auc: 0.7342 - precision: 0.6598 - recall: 0.6697 - roc_auc: 0.8620   
Epoch 8: val_dice_coefficient improved from 0.59639 to 0.60129, saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras

Epoch 8: finished saving model to D:\Final\02_Output\Jongro_Landcover_Road_Finetune\04_road_unet_landcover_finetuned.keras
3006/3006 ━━━━━━━━━━━━━━━━━━━━ 1433s 477ms/step - accuracy: 0.7910 - dice_coefficient: 0.5638 - loss: 1.0079 - pr_auc: 0.7342 - precision: 0.6598 - recall: 0.6697 - roc_auc: 0.8620 - val_accuracy: 0.8001 - val_dice_coefficient: 0.6013 - val_loss: 0.8429 - val_pr_auc: 0.7836 - val_precision: 0.7442 - val_recall: 0.5844 - val_roc_auc: 0.8844 - learning_rate: 1.0000e-05
Restoring model weights from the end of the best epoch: 8.
✓ 토지피복도 라벨 미세조정 학습 완료: 11811.1초 (196.85분) | RAM 1.41GB / 시스템 54%

▶ 미세조정 모델 전체 영상 추론 시작 | RAM 1.41GB / 시스템 54%
전체 영상 추론:   0%|          | 0/6082 [00:00<?, ?batch/s]
✓ 미세조정 모델 전체 영상 추론 완료: 1170.1초 (19.50분) | RAM 3.24GB / 시스템 65%
확률 최소/평균/최대: 0.00000000 / 0.23502274 / 0.99900025

▶ 임계값 0.40 후처리 시작 | RAM 3.24GB / 시스템 65%
✓ 임계값 0.40 후처리 완료: 19.8초 (0.33분) | RAM 3.31GB / 시스템 62%

▶ 임계값 0.40 폴리곤 export 시작 | RAM 3.31GB / 시스템 62%
예측 마스크 폴리곤화: 0geom [00:00, ?geom/s]
✓ 임계값 0.40 폴리곤 export 완료: 13.0초 (0.22분) | RAM 3.93GB / 시스템 68%
threshold=0.40 | 도로 픽셀=77,780,021 | 폴리곤=3,301

▶ 임계값 0.50 후처리 시작 | RAM 3.33GB / 시스템 64%
✓ 임계값 0.50 후처리 완료: 19.1초 (0.32분) | RAM 3.55GB / 시스템 61%

▶ 임계값 0.50 폴리곤 export 시작 | RAM 3.55GB / 시스템 61%
예측 마스크 폴리곤화: 0geom [00:00, ?geom/s]
✓ 임계값 0.50 폴리곤 export 완료: 11.3초 (0.19분) | RAM 3.76GB / 시스템 62%
threshold=0.50 | 도로 픽셀=61,012,745 | 폴리곤=4,565

▶ 임계값 0.60 후처리 시작 | RAM 3.19GB / 시스템 59%
✓ 임계값 0.60 후처리 완료: 18.7초 (0.31분) | RAM 3.57GB / 시스템 61%

▶ 임계값 0.60 폴리곤 export 시작 | RAM 3.57GB / 시스템 61%
예측 마스크 폴리곤화: 0geom [00:00, ?geom/s]
✓ 임계값 0.60 폴리곤 export 완료: 11.8초 (0.20분) | RAM 3.68GB / 시스템 64%
threshold=0.60 | 도로 픽셀=48,051,276 | 폴리곤=4,895

==============================================================================
모든 처리 완료
결과 폴더: D:\Final\02_Output\Jongro_Landcover_Road_Finetune
임계값 비교표: D:\Final\02_Output\Jongro_Landcover_Road_Finetune\threshold_comparison_summary.csv
==============================================================================

▲ 세분류 토지 피복지도의 도로

▲ 세분류 토지 피복지도의 도로를 이용한 학습/탐지 결과

그러나 세분류 토지피복지도의 도로 클래스는 차량이나 보행자의 실제 이동 경로만을 구분한 데이터가 아니었다. 일부 구간에서는 도로와 연결된 광장, 주차장, 넓은 포장면 등도 함께 도로 영역으로 분류되어 있었다. 이 영역들을 그대로 정답 라벨로 사용하면 모델은 선형적인 통행로뿐 아니라 도로 주변의 넓은 포장 공간까지 모두 도로로 학습하게 된다.

세분류 토지피복지도를 이용한 Fine-tuning 이후에는 기존 모델에서 누락되던 골목길과 협소도로가 이전보다 많이 탐지되는 것을 확인할 수 있었다. 이는 세분류 토지피복지도가 표준노드링크보다 훨씬 세밀한 도로 정보를 포함하고 있었기 때문으로 판단된다.

그러나 예측 결과를 정사영상과 비교한 결과, 도로뿐 아니라 건물 주변의 넓은 포장면과 광장, 주차장 등이 함께 도로로 분류되는 현상이 확인되었다. 일부 구간에서는 건물 외곽을 따라 넓은 영역이 도로로 확장되거나, 실제 도로 폭보다 훨씬 넓게 예측되는 과대 분할이 발생하였다.

이는 세분류 토지피복지도의 도로 클래스가 실제 차량 통행로뿐 아니라 다양한 포장 공간을 함께 포함하고 있기 때문으로 판단된다. 즉, 모델은 라벨에 포함된 모든 영역을 도로의 특성으로 학습하였으며, 그 결과 미세도로 탐지 성능은 향상되었지만 도로 경계는 이전보다 거칠어지고 비도로 영역까지 함께 예측하는 경향이 나타났다.

결과적으로 세분류 토지피복지도는 미세도로에 대한 공간 정보를 보완하는 데에는 효과적이었지만, 본 연구에서 목표로 하는 '실제 통행 가능한 선형 도로'와 토지피복도에서 정의하는 '도로 및 포장면'의 개념이 서로 일치하지 않아 추가적인 라벨 정제가 필요함을 확인하였다.

이 문제를 해결하기 위해 도로 Polygon 전체를 정답으로 사용하는 대신, 통행 가능한 영역만 학습시키는 방법을 고민하기 시작하였다.

가장 먼저 떠올린 아이디어는 도로 Polygon 내부에서 중심선을 추출한 뒤, 중심선을 기준으로 약 2m 정도의 얇은 Buffer를 생성하여 새로운 학습 라벨로 사용하는 것이었다.

이렇게 하면 광장이나 넓은 포장면은 대부분 제외하면서도 실제 차량이나 보행자가 이용하는 도로 중심부만 모델에게 학습시킬 수 있을 것으로 기대하였다.

처음에는 Polygon 내부에서 중심선을 생성하는 방법으로 Voronoi 기반 중심선 추출을 검토하였다.

그러나 실제 적용 결과 중심선이 매우 잘게 끊어지고 불필요한 가지(branch)가 많이 생성되었다. 특히 복잡한 형태의 교차로나 굴곡이 있는 도로에서는 중심선이 불안정하게 생성되어 학습 라벨로 사용하기에는 적합하지 않았다.

▲ Voronio 기반 중심선 추출 결과

이후 여러 중심선 추출 방법을 비교한 결과 Skeletonization(골격화) 기법을 적용하기로 하였다.

Skeleton은 Polygon 내부를 한 픽셀 두께의 중심선으로 점진적으로 수축시키면서 전체 연결성을 최대한 유지하는 방식이다. 따라서 Voronoi보다 실제 도로 중심을 안정적으로 표현할 수 있었으며, 복잡한 도로 형태에서도 끊김이 적고 연속성이 높은 중심선을 생성할 수 있었다.

이를 기반으로 중심선 주변에 약 2m Buffer를 생성하여 새로운 학습 라벨을 구축하는 실험을 진행하였다.

▲ Skeletonization 기법을 적용한 중심선 추출 결과

▲ Voronio 기반 중심선과 Skeletonization 기반 중심선 차이 (ChatGPT 사용 그림)

해당 과정 이후 생성된 도로 라벨을 정사영상과 대조하며 수작업으로 검수하였다. 이 과정에서 수목에 가려져 토지피복도에서는 도로로 적절히 표현되지 않았으나 실제 통행이 가능한 임도와 같은 예외 사례를 확인하였으며, 반대로 세분류 토지피복지도 구축 당시에는 도로로 분류되었지만 현재는 공사, 재개발 또는 토지 이용 변화로 인해 더 이상 도로로 사용되지 않는 구간은 학습 라벨에서 제외하였다.

해당 코드 (펼치기) ▼

# -*- coding: utf-8 -*-
"""
세분류 토지피복 도로 폴리곤 → 타일 기반 중심선 추출
======================================================================

핵심 흐름
    도로 폴리곤
    → 타일별 조회
    → 2m 래스터화
    → 형태학적 잡음 정리
    → skeletonize
    → 중심선 벡터화
    → 짧은 가지 제거
    → 타일 경계 중복 제거
    → GPKG 저장

특징
- Voronoi 방식 사용 안 함
- 서울 전체 래스터를 한 번에 만들지 않음
- 타일 겹침 영역을 사용하여 타일 경계 단절 최소화
- Jupyter와 .py 실행 모두 가능
- tqdm 진행률과 예상 잔여 시간 표시

필수 패키지
    pip install -U geopandas pyogrio rasterio shapely scikit-image scipy tqdm

권장
    shapely >= 2.0
    geopandas >= 0.14
    rasterio >= 1.3
    scikit-image >= 0.22
"""

from __future__ import annotations

import math
import os
import time
import warnings
from pathlib import Path
from typing import Iterable

import geopandas as gpd
import numpy as np
import pandas as pd
from affine import Affine
from rasterio.features import rasterize
from shapely import make_valid
from shapely.geometry import (
    LineString,
    MultiLineString,
    Polygon,
    box,
)
from shapely.ops import linemerge, unary_union
from skimage.morphology import (
    binary_closing,
    binary_opening,
    disk,
    remove_small_holes,
    remove_small_objects,
    skeletonize,
)
from tqdm import tqdm

warnings.filterwarnings("ignore", category=UserWarning)


# =============================================================================
# 1. 사용자 설정
# =============================================================================

INPUT_FILE = Path(
    r"C:\Users\itwill\Desktop\세분류\세분류_도로_154_통합.shp"
)

OUTPUT_GPKG = Path(
    r"C:\Users\itwill\Desktop\세분류\road_centerline_tile_2m_preview.gpkg"
)

TARGET_CRS = "EPSG:5179"

# -------------------------------------------------------------------------
# 1차 미리보기 권장값
# -------------------------------------------------------------------------

# 픽셀 크기(m)
RESOLUTION_M = 2.0

# 한 타일의 본체 크기(픽셀)
# 2048 × 2m = 약 4.096km
TILE_SIZE_PIXELS = 2048

# 타일 외곽에 추가로 읽는 중첩 폭(픽셀)
# 중심선은 마지막에 본체 영역으로 잘라서 중복을 제거함
TILE_OVERLAP_PIXELS = 64

# 도로 면의 작은 틈을 메우는 closing 반경(픽셀)
# 1픽셀 = 2m이므로 1이면 약 2m
CLOSING_RADIUS_PIXELS = 1

# 고립된 작은 돌기 제거용 opening 반경(픽셀)
# 너무 크게 하면 좁은 도로가 사라질 수 있으므로 기본 0
OPENING_RADIUS_PIXELS = 0

# 작은 도로 조각 제거 면적(㎡)
MIN_ROAD_COMPONENT_AREA_M2 = 40.0

# 작은 내부 구멍을 메우는 최대 면적(㎡)
MAX_HOLE_AREA_M2 = 36.0

# 중심선의 짧은 가지 제거 기준(m)
MIN_BRANCH_LENGTH_M = 20.0

# 최종 선 단순화 허용오차(m)
SIMPLIFY_TOLERANCE_M = 1.5

# 입력 폴리곤 최소 면적(㎡)
MIN_INPUT_POLYGON_AREA_M2 = 10.0

# 래스터화 시 픽셀 중심만 포함할지 여부
# False가 도로 폭 과대 추출을 줄이는 데 유리
ALL_TOUCHED = False

# 최종 전체 선 병합 여부
# True면 타일 경계의 중복·분절을 정리하지만 마지막 단계가 조금 오래 걸릴 수 있음
GLOBAL_MERGE = True

# 디버그용 타일 경계 레이어 저장
SAVE_TILE_GRID = False

# 오류 CSV 저장
SAVE_ERROR_CSV = True


# =============================================================================
# 2. 입력 전처리
# =============================================================================

def load_road_polygons() -> gpd.GeoDataFrame:
    if not INPUT_FILE.exists():
        raise FileNotFoundError(f"입력 파일이 없습니다:\n{INPUT_FILE}")

    print(f"입력 읽는 중: {INPUT_FILE}")

    roads = gpd.read_file(INPUT_FILE, engine="pyogrio")

    if roads.empty:
        raise ValueError("입력 파일에 객체가 없습니다.")

    if roads.crs is None:
        raise ValueError(
            "입력 데이터에 좌표계가 없습니다. "
            "QGIS에서 올바른 좌표계를 먼저 지정하세요."
        )

    roads = roads.to_crs(TARGET_CRS)

    roads = roads[
        roads.geometry.notna()
        & ~roads.geometry.is_empty
    ].copy()

    roads["geometry"] = roads.geometry.apply(make_valid)

    roads = roads.explode(
        index_parts=False,
        ignore_index=True,
    )

    roads = roads[
        roads.geometry.geom_type.isin(["Polygon", "MultiPolygon"])
    ].copy()

    roads = roads[
        roads.geometry.area >= MIN_INPUT_POLYGON_AREA_M2
    ].copy()

    roads = roads.reset_index(drop=True)

    if roads.empty:
        raise ValueError("유효한 도로 폴리곤이 없습니다.")

    # 공간 인덱스 미리 생성
    _ = roads.sindex

    print(f"처리 대상 폴리곤: {len(roads):,}개")
    print(f"총 도로 면적: {roads.geometry.area.sum():,.1f}㎡")

    return roads


# =============================================================================
# 3. 타일 생성
# =============================================================================

def align_down(value: float, step: float) -> float:
    return math.floor(value / step) * step


def align_up(value: float, step: float) -> float:
    return math.ceil(value / step) * step


def build_tile_grid(
    roads: gpd.GeoDataFrame,
) -> list[dict]:
    minx, miny, maxx, maxy = roads.total_bounds

    core_size_m = TILE_SIZE_PIXELS * RESOLUTION_M
    overlap_m = TILE_OVERLAP_PIXELS * RESOLUTION_M

    grid_minx = align_down(minx, core_size_m)
    grid_miny = align_down(miny, core_size_m)
    grid_maxx = align_up(maxx, core_size_m)
    grid_maxy = align_up(maxy, core_size_m)

    n_cols = int(round((grid_maxx - grid_minx) / core_size_m))
    n_rows = int(round((grid_maxy - grid_miny) / core_size_m))

    tiles = []
    tile_id = 0

    for row in range(n_rows):
        for col in range(n_cols):
            core_minx = grid_minx + col * core_size_m
            core_miny = grid_miny + row * core_size_m
            core_maxx = core_minx + core_size_m
            core_maxy = core_miny + core_size_m

            core_geom = box(
                core_minx,
                core_miny,
                core_maxx,
                core_maxy,
            )

            # 도로가 전혀 없는 타일은 제외
            candidate_idx = list(
                roads.sindex.query(
                    core_geom,
                    predicate="intersects",
                )
            )

            if not candidate_idx:
                continue

            tile_id += 1

            tiles.append(
                {
                    "tile_id": tile_id,
                    "row": row,
                    "col": col,
                    "core_bounds": (
                        core_minx,
                        core_miny,
                        core_maxx,
                        core_maxy,
                    ),
                    "expanded_bounds": (
                        core_minx - overlap_m,
                        core_miny - overlap_m,
                        core_maxx + overlap_m,
                        core_maxy + overlap_m,
                    ),
                    "core_geometry": core_geom,
                }
            )

    print(f"도로가 포함된 처리 타일: {len(tiles):,}개")

    return tiles


# =============================================================================
# 4. 타일 래스터화 및 형태학적 정리
# =============================================================================

def rasterize_tile(
    roads: gpd.GeoDataFrame,
    expanded_bounds: tuple[float, float, float, float],
) -> tuple[np.ndarray, Affine]:
    minx, miny, maxx, maxy = expanded_bounds

    width = int(round((maxx - minx) / RESOLUTION_M))
    height = int(round((maxy - miny) / RESOLUTION_M))

    transform = Affine(
        RESOLUTION_M,
        0.0,
        minx,
        0.0,
        -RESOLUTION_M,
        maxy,
    )

    tile_geom = box(minx, miny, maxx, maxy)

    candidate_idx = list(
        roads.sindex.query(
            tile_geom,
            predicate="intersects",
        )
    )

    if not candidate_idx:
        return np.zeros((height, width), dtype=bool), transform

    clipped_geometries = []

    for geom in roads.geometry.iloc[candidate_idx]:
        clipped = geom.intersection(tile_geom)

        if clipped.is_empty:
            continue

        if clipped.geom_type == "Polygon":
            clipped_geometries.append(clipped)

        elif clipped.geom_type == "MultiPolygon":
            clipped_geometries.extend(
                part
                for part in clipped.geoms
                if not part.is_empty
            )

    if not clipped_geometries:
        return np.zeros((height, width), dtype=bool), transform

    mask = rasterize(
        (
            (geom, 1)
            for geom in clipped_geometries
        ),
        out_shape=(height, width),
        transform=transform,
        fill=0,
        dtype="uint8",
        all_touched=ALL_TOUCHED,
    ).astype(bool)

    min_component_pixels = max(
        1,
        int(
            round(
                MIN_ROAD_COMPONENT_AREA_M2
                / (RESOLUTION_M ** 2)
            )
        ),
    )

    max_hole_pixels = max(
        1,
        int(
            round(
                MAX_HOLE_AREA_M2
                / (RESOLUTION_M ** 2)
            )
        ),
    )

    mask = remove_small_objects(
        mask,
        min_size=min_component_pixels,
        connectivity=2,
    )

    mask = remove_small_holes(
        mask,
        area_threshold=max_hole_pixels,
        connectivity=2,
    )

    if CLOSING_RADIUS_PIXELS > 0:
        mask = binary_closing(
            mask,
            footprint=disk(CLOSING_RADIUS_PIXELS),
        )

    if OPENING_RADIUS_PIXELS > 0:
        mask = binary_opening(
            mask,
            footprint=disk(OPENING_RADIUS_PIXELS),
        )

    return mask, transform


# =============================================================================
# 5. Skeleton 픽셀 → 벡터 선
# =============================================================================

def pixel_center(
    row: int,
    col: int,
    transform: Affine,
) -> tuple[float, float]:
    x = transform.c + (col + 0.5) * transform.a
    y = transform.f + (row + 0.5) * transform.e
    return float(x), float(y)


def skeleton_to_segments(
    skeleton: np.ndarray,
    transform: Affine,
) -> list[LineString]:
    """
    8방향 연결에서 중복 없이 다음 4방향만 확인:
      오른쪽, 아래왼쪽, 아래, 아래오른쪽
    """
    rows, cols = np.nonzero(skeleton)

    if len(rows) == 0:
        return []

    foreground = set(zip(rows.tolist(), cols.tolist()))

    forward_neighbors = (
        (0, 1),
        (1, -1),
        (1, 0),
        (1, 1),
    )

    segments = []

    for row, col in foreground:
        start_xy = pixel_center(row, col, transform)

        for drow, dcol in forward_neighbors:
            nrow = row + drow
            ncol = col + dcol

            if (nrow, ncol) not in foreground:
                continue

            end_xy = pixel_center(nrow, ncol, transform)

            segments.append(
                LineString([start_xy, end_xy])
            )

    return segments


def flatten_lines(geometry) -> list[LineString]:
    if geometry is None or geometry.is_empty:
        return []

    if isinstance(geometry, LineString):
        return [geometry]

    if isinstance(geometry, MultiLineString):
        return list(geometry.geoms)

    if hasattr(geometry, "geoms"):
        lines = []

        for part in geometry.geoms:
            lines.extend(flatten_lines(part))

        return lines

    return []


def merge_and_filter_lines(
    segments: list[LineString],
    clip_geometry: Polygon,
) -> list[LineString]:
    if not segments:
        return []

    # 교차점에서 선을 분할한 뒤 연결 가능한 부분 병합
    noded = unary_union(segments)
    merged = linemerge(noded)

    candidate_lines = flatten_lines(merged)
    final_lines = []

    for line in candidate_lines:
        if line.is_empty:
            continue

        clipped = line.intersection(clip_geometry)

        for part in flatten_lines(clipped):
            if part.length < MIN_BRANCH_LENGTH_M:
                continue

            if SIMPLIFY_TOLERANCE_M > 0:
                part = part.simplify(
                    SIMPLIFY_TOLERANCE_M,
                    preserve_topology=False,
                )

            if (
                not part.is_empty
                and part.length >= MIN_BRANCH_LENGTH_M
            ):
                final_lines.append(part)

    return final_lines


# =============================================================================
# 6. 타일 처리
# =============================================================================

def process_one_tile(
    roads: gpd.GeoDataFrame,
    tile: dict,
) -> tuple[list[dict], dict | None]:
    tile_id = tile["tile_id"]

    try:
        mask, transform = rasterize_tile(
            roads,
            tile["expanded_bounds"],
        )

        if not mask.any():
            return [], None

        skeleton = skeletonize(
            mask,
            method="zhang",
        )

        segments = skeleton_to_segments(
            skeleton,
            transform,
        )

        lines = merge_and_filter_lines(
            segments,
            tile["core_geometry"],
        )

        records = []

        for part_id, line in enumerate(lines, start=1):
            records.append(
                {
                    "tile_id": tile_id,
                    "part_id": part_id,
                    "length_m": round(float(line.length), 2),
                    "geometry": line,
                }
            )

        return records, None

    except Exception as exc:
        return [], {
            "tile_id": tile_id,
            "row": tile["row"],
            "col": tile["col"],
            "error": repr(exc),
        }


# =============================================================================
# 7. 전체 실행
# =============================================================================

def run_centerline_extraction(
    roads: gpd.GeoDataFrame,
    tiles: list[dict],
) -> tuple[gpd.GeoDataFrame, pd.DataFrame]:
    records = []
    errors = []

    print()
    print("=" * 72)
    print("타일 기반 중심선 추출 시작")
    print(f"해상도: {RESOLUTION_M}m")
    print(
        f"타일 본체: {TILE_SIZE_PIXELS}px "
        f"({TILE_SIZE_PIXELS * RESOLUTION_M:,.0f}m)"
    )
    print(
        f"타일 중첩: {TILE_OVERLAP_PIXELS}px "
        f"({TILE_OVERLAP_PIXELS * RESOLUTION_M:,.0f}m)"
    )
    print(f"짧은 가지 제거: {MIN_BRANCH_LENGTH_M}m 미만")
    print("=" * 72)

    start = time.perf_counter()

    for tile in tqdm(
        tiles,
        total=len(tiles),
        desc="타일 중심선 추출",
        unit="tile",
        dynamic_ncols=True,
    ):
        tile_records, error = process_one_tile(
            roads,
            tile,
        )

        records.extend(tile_records)

        if error is not None:
            errors.append(error)

    elapsed = time.perf_counter() - start

    print()
    print(f"타일 처리 시간: {elapsed / 60:,.1f}분")

    if not records:
        raise RuntimeError(
            "생성된 중심선이 없습니다. "
            "입력 좌표계와 설정값을 확인하세요."
        )

    lines = gpd.GeoDataFrame(
        records,
        crs=roads.crs,
    )

    error_df = pd.DataFrame(errors)

    print(f"타일별 중심선 조각: {len(lines):,}개")
    print(f"오류 타일: {len(error_df):,}개")

    return lines, error_df


# =============================================================================
# 8. 전체 병합 및 최종 정리
# =============================================================================

def global_merge_centerlines(
    tile_lines: gpd.GeoDataFrame,
) -> gpd.GeoDataFrame:
    if not GLOBAL_MERGE:
        result = tile_lines.copy()
        result["centerline_id"] = np.arange(
            1,
            len(result) + 1,
            dtype=np.int64,
        )

        return result[
            [
                "centerline_id",
                "tile_id",
                "length_m",
                "geometry",
            ]
        ]

    print()
    print("타일 경계 중복 및 분절 정리 중...")

    merged_geometry = linemerge(
        unary_union(
            tile_lines.geometry.tolist()
        )
    )

    parts = flatten_lines(merged_geometry)

    records = []

    for line in parts:
        if line.is_empty:
            continue

        if line.length < MIN_BRANCH_LENGTH_M:
            continue

        if SIMPLIFY_TOLERANCE_M > 0:
            line = line.simplify(
                SIMPLIFY_TOLERANCE_M,
                preserve_topology=False,
            )

        if line.length < MIN_BRANCH_LENGTH_M:
            continue

        records.append(
            {
                "length_m": round(float(line.length), 2),
                "geometry": line,
            }
        )

    result = gpd.GeoDataFrame(
        records,
        crs=tile_lines.crs,
    )

    result["centerline_id"] = np.arange(
        1,
        len(result) + 1,
        dtype=np.int64,
    )

    return result[
        [
            "centerline_id",
            "length_m",
            "geometry",
        ]
    ]


# =============================================================================
# 9. 저장
# =============================================================================

def save_results(
    roads: gpd.GeoDataFrame,
    tiles: list[dict],
    centerlines: gpd.GeoDataFrame,
    errors: pd.DataFrame,
) -> None:
    OUTPUT_GPKG.parent.mkdir(
        parents=True,
        exist_ok=True,
    )

    if OUTPUT_GPKG.exists():
        OUTPUT_GPKG.unlink()

    print()
    print("GPKG 저장 중...")

    centerlines.to_file(
        OUTPUT_GPKG,
        layer="road_centerline_2m",
        driver="GPKG",
        engine="pyogrio",
    )

    if SAVE_TILE_GRID:
        tile_grid = gpd.GeoDataFrame(
            [
                {
                    "tile_id": tile["tile_id"],
                    "row": tile["row"],
                    "col": tile["col"],
                    "geometry": tile["core_geometry"],
                }
                for tile in tiles
            ],
            crs=roads.crs,
        )

        tile_grid.to_file(
            OUTPUT_GPKG,
            layer="processing_tiles",
            driver="GPKG",
            engine="pyogrio",
        )

    if SAVE_ERROR_CSV and not errors.empty:
        error_path = OUTPUT_GPKG.with_name(
            OUTPUT_GPKG.stem + "_errors.csv"
        )

        errors.to_csv(
            error_path,
            index=False,
            encoding="utf-8-sig",
        )

        print(f"오류 CSV: {error_path}")

    print(f"결과 파일: {OUTPUT_GPKG}")
    print("결과 레이어: road_centerline_2m")


# =============================================================================
# 10. 메인
# =============================================================================

def main() -> None:
    print("=" * 72)
    print("도로 폴리곤 타일 기반 2m 중심선 추출")
    print("=" * 72)

    roads = load_road_polygons()
    tiles = build_tile_grid(roads)

    tile_lines, errors = run_centerline_extraction(
        roads,
        tiles,
    )

    centerlines = global_merge_centerlines(
        tile_lines,
    )

    print()
    print(f"최종 중심선 개수: {len(centerlines):,}개")
    print(
        f"최종 중심선 총길이: "
        f"{centerlines.geometry.length.sum() / 1000:,.2f}km"
    )

    save_results(
        roads,
        tiles,
        centerlines,
        errors,
    )

    print()
    print("전체 작업 완료")


if __name__ == "__main__":
    main()

결과 (펼치기) ▼

PROJ DB 선택: C:\Users\itwill\anaconda3\Lib\site-packages\rasterio\proj_data\proj.db
PROJ DB minor: 6
==============================================================================
2개 정사영상 + 2m 중심선 약한 라벨 파인튜닝
==============================================================================
PROJ DATA: C:\Users\itwill\anaconda3\Lib\site-packages\rasterio\proj_data
TensorFlow GPU: []
기존 모델: D:\Final\02_Output\Jongro_Ortho_Road_Segmentation_v3\04_road_unet.keras
약한 라벨 중심선: D:\Final\03_sebunryu\2m_centerline.gpkg
출력 폴더: D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles

▶ 정사영상 2장 모자이크 시작 | RAM 1.52GB / 시스템 69%
기존 모자이크 재사용: D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\01_two_tile_orthomosaic_5179_050cm.tif
✓ 정사영상 2장 모자이크 완료: 0.0초 (0.00분) | RAM 1.52GB / 시스템 69%
모자이크 CRS: EPSG:5179
모자이크 크기: 9,063 × 11,274

▶ 중심선 2m 버퍼 약한 라벨 생성 시작 | RAM 1.52GB / 시스템 69%
자동 선택 중심선 레이어: road_centerline_tile_2m_preview__road_centerline_2m
영상 범위 중심선: 11,876개
중심선 총길이: 466.23km
약한 라벨 rasterize 입력:   0%|          | 0/11876 [00:00<?, ?geom/s]
약한 라벨 양성 픽셀 비율: 0.0854
✓ 중심선 2m 버퍼 약한 라벨 생성 완료: 2.9초 (0.05분) | RAM 1.62GB / 시스템 70%

▶ 밴드 정규화 통계 시작 | RAM 1.72GB / 시스템 70%
밴드별 2~98 percentile: [(0.0, 182.0), (0.0, 188.0), (0.0, 172.0)]
✓ 밴드 정규화 통계 완료: 0.0초 (0.00분) | RAM 1.72GB / 시스템 70%

▶ 학습·검증 패치 구성 시작 | RAM 1.72GB / 시스템 70%
파인튜닝 패치 검사:   0%|          | 0/6160 [00:00<?, ?patch/s]
양성 패치: 2,819
배경 패치 사용: 296
학습 패치: 2,648
검증 패치: 467
✓ 학습·검증 패치 구성 완료: 6.3초 (0.11분) | RAM 1.69GB / 시스템 69%

▶ 기존 베스트 모델 약한 라벨 파인튜닝 시작 | RAM 1.69GB / 시스템 69%
기존 모델 입력 형태: (None, 256, 256, 3)
Epoch 1/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 457ms/step - accuracy: 0.8923 - dice_coefficient: 0.1967 - loss: 1.3812 - pr_auc: 0.1458 - precision: 0.1998 - recall: 0.0670 - roc_auc: 0.6362   
Epoch 1: val_dice_coefficient improved from None to 0.18133, saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 1: finished saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras
662/662 ━━━━━━━━━━━━━━━━━━━━ 329s 483ms/step - accuracy: 0.8923 - dice_coefficient: 0.1967 - loss: 1.3812 - pr_auc: 0.1458 - precision: 0.1998 - recall: 0.0670 - roc_auc: 0.6362 - val_accuracy: 0.9106 - val_dice_coefficient: 0.1813 - val_loss: 1.2940 - val_pr_auc: 0.1457 - val_precision: 0.1940 - val_recall: 0.0091 - val_roc_auc: 0.6578 - learning_rate: 1.0000e-05
Epoch 2/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 465ms/step - accuracy: 0.9031 - dice_coefficient: 0.2014 - loss: 1.3221 - pr_auc: 0.1520 - precision: 0.2120 - recall: 0.0294 - roc_auc: 0.6529  
Epoch 2: val_dice_coefficient improved from 0.18133 to 0.19694, saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 2: finished saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras
662/662 ━━━━━━━━━━━━━━━━━━━━ 323s 487ms/step - accuracy: 0.9031 - dice_coefficient: 0.2014 - loss: 1.3221 - pr_auc: 0.1520 - precision: 0.2120 - recall: 0.0294 - roc_auc: 0.6529 - val_accuracy: 0.9017 - val_dice_coefficient: 0.1969 - val_loss: 1.2672 - val_pr_auc: 0.1590 - val_precision: 0.2388 - val_recall: 0.0603 - val_roc_auc: 0.6692 - learning_rate: 1.0000e-05
Epoch 3/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 449ms/step - accuracy: 0.9004 - dice_coefficient: 0.2101 - loss: 1.2868 - pr_auc: 0.1567 - precision: 0.2237 - recall: 0.0447 - roc_auc: 0.6610  
Epoch 3: val_dice_coefficient improved from 0.19694 to 0.20462, saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 3: finished saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras
662/662 ━━━━━━━━━━━━━━━━━━━━ 312s 471ms/step - accuracy: 0.9004 - dice_coefficient: 0.2101 - loss: 1.2868 - pr_auc: 0.1567 - precision: 0.2237 - recall: 0.0447 - roc_auc: 0.6610 - val_accuracy: 0.8954 - val_dice_coefficient: 0.2046 - val_loss: 1.2222 - val_pr_auc: 0.1685 - val_precision: 0.2501 - val_recall: 0.1020 - val_roc_auc: 0.6829 - learning_rate: 1.0000e-05
Epoch 4/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 461ms/step - accuracy: 0.8967 - dice_coefficient: 0.2085 - loss: 1.2771 - pr_auc: 0.1594 - precision: 0.2260 - recall: 0.0626 - roc_auc: 0.6653  
Epoch 4: val_dice_coefficient did not improve from 0.20462

Epoch 4: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-06.
662/662 ━━━━━━━━━━━━━━━━━━━━ 321s 484ms/step - accuracy: 0.8967 - dice_coefficient: 0.2085 - loss: 1.2771 - pr_auc: 0.1594 - precision: 0.2260 - recall: 0.0626 - roc_auc: 0.6653 - val_accuracy: 0.8949 - val_dice_coefficient: 0.2038 - val_loss: 1.2336 - val_pr_auc: 0.1659 - val_precision: 0.2391 - val_recall: 0.0963 - val_roc_auc: 0.6815 - learning_rate: 1.0000e-05
Epoch 5/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 458ms/step - accuracy: 0.8975 - dice_coefficient: 0.2123 - loss: 1.2656 - pr_auc: 0.1609 - precision: 0.2286 - recall: 0.0604 - roc_auc: 0.6684  
Epoch 5: val_dice_coefficient improved from 0.20462 to 0.21061, saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 5: finished saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 5: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-06.
662/662 ━━━━━━━━━━━━━━━━━━━━ 317s 479ms/step - accuracy: 0.8975 - dice_coefficient: 0.2123 - loss: 1.2656 - pr_auc: 0.1609 - precision: 0.2286 - recall: 0.0604 - roc_auc: 0.6684 - val_accuracy: 0.8920 - val_dice_coefficient: 0.2106 - val_loss: 1.2243 - val_pr_auc: 0.1706 - val_precision: 0.2422 - val_recall: 0.1142 - val_roc_auc: 0.6883 - learning_rate: 5.0000e-06
Epoch 6/6
662/662 ━━━━━━━━━━━━━━━━━━━━ 0s 450ms/step - accuracy: 0.8954 - dice_coefficient: 0.2102 - loss: 1.2613 - pr_auc: 0.1620 - precision: 0.2290 - recall: 0.0702 - roc_auc: 0.6712  
Epoch 6: val_dice_coefficient improved from 0.21061 to 0.21108, saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras

Epoch 6: finished saving model to D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles\03_weaklabel_finetuned_best.keras
662/662 ━━━━━━━━━━━━━━━━━━━━ 312s 472ms/step - accuracy: 0.8954 - dice_coefficient: 0.2102 - loss: 1.2613 - pr_auc: 0.1620 - precision: 0.2290 - recall: 0.0702 - roc_auc: 0.6712 - val_accuracy: 0.8939 - val_dice_coefficient: 0.2111 - val_loss: 1.1925 - val_pr_auc: 0.1720 - val_precision: 0.2471 - val_recall: 0.1080 - val_roc_auc: 0.6927 - learning_rate: 2.5000e-06
Restoring model weights from the end of the best epoch: 6.
✓ 기존 베스트 모델 약한 라벨 파인튜닝 완료: 1916.0초 (31.93분) | RAM 1.66GB / 시스템 65%

▶ 기존 모델 동일 영상 추론 시작 | RAM 1.66GB / 시스템 65%
04_baseline 전체 추론:   0%|          | 0/1540 [00:00<?, ?batch/s]
마스크 폴리곤화: 0geom [00:00, ?geom/s]
04_baseline 양성 픽셀 비율: 0.0603
04_baseline 예측 폴리곤: 492개
WARNING:tensorflow:From C:\Users\itwill\anaconda3\Lib\site-packages\keras\src\backend\common\global_state.py:82: The name tf.reset_default_graph is deprecated. Please use tf.compat.v1.reset_default_graph instead.

✓ 기존 모델 동일 영상 추론 완료: 308.7초 (5.15분) | RAM 1.64GB / 시스템 70%

▶ 파인튜닝 모델 동일 영상 추론 시작 | RAM 1.64GB / 시스템 70%
05_finetuned 전체 추론:   0%|          | 0/1540 [00:00<?, ?batch/s]
마스크 폴리곤화: 0geom [00:00, ?geom/s]
05_finetuned 양성 픽셀 비율: 0.0280
05_finetuned 예측 폴리곤: 1,612개
✓ 파인튜닝 모델 동일 영상 추론 완료: 360.2초 (6.00분) | RAM 1.69GB / 시스템 75%

▶ 기존 모델 대비 변화 영역 생성 시작 | RAM 1.69GB / 시스템 75%
마스크 폴리곤화: 0geom [00:00, ?geom/s]
06_added_after_finetune: 886,788픽셀, 1,211개 폴리곤
마스크 폴리곤화: 0geom [00:00, ?geom/s]
07_removed_after_finetune: 4,178,879픽셀, 669개 폴리곤
✓ 기존 모델 대비 변화 영역 생성 완료: 9.0초 (0.15분) | RAM 1.71GB / 시스템 76%

==============================================================================
완료
출력 폴더: D:\Final\02_Output\Jongro_WeakLabel_Finetune_2Tiles
==============================================================================

▲ Skeletonization 기반 중심선을 이용한 학습/탐지 결과

하지만 결과는 기대와 달랐다. 넓게 퍼지던 오탐은 줄었지만, 이번에는 도로가 짧게 끊기거나 가느다란 선분처럼 파편화되어 나타났다. 특히 교차로나 넓은 도로에서는 실제 도로 폭을 제대로 표현하지 못했다.

(여러 방식을 종로구 전체에 반복 적용하기에는 시간이 너무 오래 걸렸기 때문에, 이 단계부터는 정사영상 TIFF 2개만 선정해 실험하였다. 먼저 작은 범위에서 라벨 방식이 실제 도로를 제대로 설명하는지 확인한 뒤, 효과가 검증된 방법만 전체 지역에 적용하려는 목적이었다. 무엇보다 이 모델은 이후 다른 자치구를 Fine-tuning하기 위한 기준 모델이므로, 종로구에서부터 도로의 형태를 안정적으로 설명할 수 있어야 했다.)

자동 생성된 라벨을 여러 차례 검토한 결과, 연구 목적에 부합하는 정답 데이터를 구축하기 위해서는 직접 라벨을 작성하는 것이 가장 적절하다고 판단하였다. 이에 따라 하나의 정사영상 TIFF 도엽을 선정하고, 영상에서 육안으로 통행 가능한 도로의 중심선을 직접 디지타이징하였다. 이후 수작업 중심선을 기준으로 약 2m의 Buffer를 생성하여, 연구 목적을 비교적 명확하게 반영한 고품질 정답 라벨로 사용하였다.

표준노드링크 기반 학습에서 가장 우수한 성능을 보인 U-Net 모델을 초기 모델로 불러온 뒤, 수작업 라벨이 구축된 정사영상을 이용하여 Fine-tuning을 수행하였다. 이후 모델의 성능을 두 가지 관점에서 확인하였다. 먼저 학습 라벨을 구축한 동일한 정사영상에서 수작업 도로를 얼마나 충실하게 재현하는지 확인하고, 다음으로 학습에 사용하지 않은 종로구 내 다른 정사영상에 적용하여 새로운 공간에서도 도로의 특징을 탐지할 수 있는지 검토하였다.

이를 위해 총 2개의 정사영상 TIFF 도엽을 사용하였다. 첫 번째 도엽은 수작업 라벨 구축과 Fine-tuning에 사용한 학습 대상 영상이며, 두 번째 도엽은 동일한 자치구에 위치하지만 추가 학습에는 사용하지 않은 외부 검증용 영상이다. 이를 통해 모델이 학습 영상을 단순히 기억한 것인지, 아니면 동일 지역의 다른 영상에도 적용 가능한 도로의 시각적 특징을 학습한 것인지를 정성적으로 비교하고자 하였다.

▲ 디지타이징한 도로 중심선

도로탐지결과 (펼치기) ▼

================================================================================
종로구 전체 정사영상 도로 탐지
추가 학습 없음 / 타일별 정규화 추론
================================================================================

모델: D:\Final\02_Output\Jongro_Digit_StrongLabel_Finetune_B060\03_digit_stronglabel_finetuned_best.keras
입력 폴더: D:\Final\00_Raw\06_map_25\01_jongro\georeferenced
TIFF 수: 12
출력 폴더: D:\Final\02_Output\Jongro_Digit_Model_Full_Test_PerTileNorm
임계값: 0.40
최소 폴리곤 면적: 8.00 m²

[1/4] 베스트모델 로드
  모델: D:\Final\02_Output\Jongro_Digit_StrongLabel_Finetune_B060\03_digit_stronglabel_finetuned_best.keras
  입력 형태: (None, 256, 256, 3)
  출력 형태: (None, 256, 256, 1)

[2/4] 종로구 전체 TIFF 순차 추론

[1/12] (B060)정사영상_2025_37608048_EPSG5179.tif
  LOW RGB : [12. 31. 25.]
  HIGH RGB: [160. 169. 154.]
  완료: (B060)정사영상_2025_37608048_EPSG5179.tif | 도로 픽셀 비율 3.15% | 폴리곤 615개                    

[2/12] (B060)정사영상_2025_37608049_EPSG5179.tif
  LOW RGB : [ 7. 19. 16.]
  HIGH RGB: [119. 125. 102.]
  완료: (B060)정사영상_2025_37608049_EPSG5179.tif | 도로 픽셀 비율 4.14% | 폴리곤 2,955개                  

[3/12] (B060)정사영상_2025_37608050_EPSG5179.tif
  LOW RGB : [13. 28. 22.]
  HIGH RGB: [86. 91. 71.]
  완료: (B060)정사영상_2025_37608050_EPSG5179.tif | 도로 픽셀 비율 1.61% | 폴리곤 670개                    

[4/12] (B060)정사영상_2025_37608058_EPSG5179.tif
  LOW RGB : [ 4. 21. 19.]
  HIGH RGB: [170. 182. 172.]
  완료: (B060)정사영상_2025_37608058_EPSG5179.tif | 도로 픽셀 비율 5.65% | 폴리곤 1,058개                  

[5/12] (B060)정사영상_2025_37608059_EPSG5179.tif
  LOW RGB : [ 6. 20. 17.]
  HIGH RGB: [146. 159. 145.]
  완료: (B060)정사영상_2025_37608059_EPSG5179.tif | 도로 픽셀 비율 4.55% | 폴리곤 758개                    

[6/12] (B060)정사영상_2025_37608060_EPSG5179.tif
  LOW RGB : [ 7. 20. 17.]
  HIGH RGB: [136. 151. 136.]
  완료: (B060)정사영상_2025_37608060_EPSG5179.tif | 도로 픽셀 비율 2.87% | 폴리곤 689개                    

[7/12] (B060)정사영상_2025_37608069_EPSG5179.tif
  LOW RGB : [ 4. 14. 11.]
  HIGH RGB: [157. 168. 152.]
  완료: (B060)정사영상_2025_37608069_EPSG5179.tif | 도로 픽셀 비율 5.78% | 폴리곤 1,140개                  

[8/12] (B060)정사영상_2025_37608070_EPSG5179.tif
  LOW RGB : [ 7. 20. 14.]
  HIGH RGB: [176. 181. 165.]
  완료: (B060)정사영상_2025_37608070_EPSG5179.tif | 도로 픽셀 비율 6.63% | 폴리곤 1,032개                  

[9/12] (B060)정사영상_2025_37608079_EPSG5179.tif
  LOW RGB : [26. 52. 42.]
  HIGH RGB: [192. 196. 181.]
  완료: (B060)정사영상_2025_37608079_EPSG5179.tif | 도로 픽셀 비율 4.96% | 폴리곤 2,568개                  

[10/12] (B060)정사영상_2025_37608080_EPSG5179.tif
  LOW RGB : [15. 39. 27.]
  HIGH RGB: [187. 193. 179.]
  완료: (B060)정사영상_2025_37608080_EPSG5179.tif | 도로 픽셀 비율 5.54% | 폴리곤 2,636개                  

[11/12] (B060)정사영상_2025_37705061_EPSG5179.tif
  LOW RGB : [ 8. 29. 29.]
  HIGH RGB: [184. 195. 185.]
  완료: (B060)정사영상_2025_37705061_EPSG5179.tif | 도로 픽셀 비율 7.44% | 폴리곤 2,290개                  

[12/12] (B060)정사영상_2025_37705071_EPSG5179.tif
  LOW RGB : [18. 43. 38.]
  HIGH RGB: [191. 196. 184.]
  완료: (B060)정사영상_2025_37705071_EPSG5179.tif | 도로 픽셀 비율 5.33% | 폴리곤 2,980개                  

[3/4] 타일별 도로 폴리곤 병합
폴리곤 읽기: 100%|██████████| 12/12 [00:01<00:00,  7.75it/s]
  통합 폴리곤 수: 19,391
  저장: D:\Final\02_Output\Jongro_Digit_Model_Full_Test_PerTileNorm\Jongro_all_predicted_roads.gpkg

[4/4] 처리 요약
  전체 TIFF: 12
  폴리곤 생성 타일: 12
  실패 타일: 0
  요약: D:\Final\02_Output\Jongro_Digit_Model_Full_Test_PerTileNorm\processing_summary.txt
  전체 통합 GPKG: D:\Final\02_Output\Jongro_Digit_Model_Full_Test_PerTileNorm\Jongro_all_predicted_roads.gpkg

================================================================================
완료
================================================================================

출력 구조
normalization\ : 타일별 RGB 정규화 기록
probability\   : 타일별 도로 확률 TIFF
binary_mask\   : 타일별 이진 마스크 TIFF
polygon\       : 타일별 도로 폴리곤 GPKG
Jongro_all_predicted_roads.gpkg
                : 종로구 전체 통합 폴리곤

▲ 디지타이징한 도로 중심선 + 2m buffer를 사용한 학습/탐지 결과

수작업으로 디지타이징한 도로 중심선과 2m Buffer를 이용해 Fine-tuning한 결과, 앞선 실험들보다 생활도로와 골목길의 연속성이 뚜렷하게 개선되었다. 특히 학습에 사용하지 않은 동일 자치구 내 다른 정사영상에서도 주요 도로뿐 아니라 일부 협소도로까지 비교적 잘 추출되어, 수작업 라벨이 모델의 공간적 일반화에 일정 부분 기여했음을 확인할 수 있었다.

그러나 예측 결과에는 여전히 상당한 노이즈가 남아 있었다. 건물 경계, 옥상, 주차장, 그림자, 밝은 포장면과 같이 도로와 유사한 시각적 특징을 가진 영역이 부분적으로 도로로 오분류되었고, 일부 구간에서는 짧은 선분이나 작은 폐곡선 형태의 예측이 다수 발생하였다.

앞서 수작업으로 구축한 중심선 라벨을 이용한 Fine-tuning에서도 생활도로의 탐지 성능은 개선되었지만, 중심선을 기준으로 동일한 2m Buffer를 적용하면서 도로의 실제 폭을 충분히 반영하지 못하는 문제가 남아 있었다. 광폭도로는 실제 도로의 일부 영역만 정답으로 학습되는 반면, 협소한 골목길에서는 Buffer가 건물 가장자리 등 비도로 영역까지 포함하기도 하였다. 이에 중심선이 아닌 실제 도로 경계를 Polygon 형태로 직접 디지타이징하여 정답 데이터를 다시 구축하기로 하였다.

다만 수작업 Polygon 구축에는 상당한 시간이 소요되므로, 이번 단계에서는 종로구 전체가 아닌 정사영상 TIFF 1개 도엽을 대상으로 고품질 정답 데이터를 구축하였다. 이는 종로구 전체를 대표하는 학습데이터를 완성하기 위한 단계라기보다, 정확하게 구축한 소규모 정답 데이터가 기존 모델의 탐지 결과를 개선할 수 있는지 우선 확인하기 위한 실험이다. 이후 해당 데이터를 이용해 Fine-tuning을 진행하고, 학습에 사용하지 않은 다른 정사영상에서도 개선 효과가 나타나는지 확인하고자 한다.

▲ 디지타이징한 도로

#5 5일차_감성 분석 (나이브베이즈, RNN)

ecosso — Wed, 29 Jul 2026 16:16:45 +0900

01 쇼핑몰 후기 감성 분석

02 참고 : 최신 java 설치

03 쇼핑몰 후기 감성 분석 - 모델링(나이브베이즈)

04 쇼핑몰 후기 감성 분석 - 모델링(RNN)

01 쇼핑몰 후기 감성 분석

# 1. 데이터 로딩
import pandas as pd
df = pd.read_table('shopping_ratings_total.txt', names = ['ratings', 'reviews'])

df.head()
df.shape          # (200000, 2)

# 2. target 변수 변환(평점 -> 이진데이터)
import numpy as np
np.unique(df['ratings'])                                        # [1, 2, 4, 5]

df['ratings'] = np.where(df['ratings'] <= 2, 0, 1)              # 평점 1,2 -> 0(부정)
# 평점 4,5 -> 1(긍정)
df['ratings'].value_counts()

# 3. 샘플링(실제 분석과정에서는 생략)
# 20만건 학습 불가 -> 1만건만 랜덤 샘플링해서 진행
df = df.sample(n=10000, random_state=0).reset_index(drop=True)  # 랜덤 샘플링 -> index 초기화

# 4. 데이터 분리(train/test)
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(df['reviews'], df['ratings'], random_state=0, stratify=df['ratings'])

# 5. 전처리(정제 -> 형태소 분석)
# pip install konlpy
import konlpy.tag
Okt = konlpy.tag.Okt()                         # RuntimeError: Java version too old. Java 9 or later is required
                                               # cmd에서 java -version
# sample 리뷰로 형태소 분석
sample = train_x.values[4]

# 1) 정제 : 불필요한 글자 제거 -> 영어, 숫자, 특수기호 등
from pandas import Series
Series(sample).replace('[^가-힣]','',regex=True)

Series(sample).replace('[^가-힣]','',regex=True)
Out[21]: 
0    살키로남자아이구매했어요타이트하게잘맞아요무엇보다소재가너무좋네요세탁후에도보풀이안나고신축...
dtype: object

# 내 컴퓨터에서 오류가 계속 발생해서 아래 코드로 진행하였음
import konlpy.tag

Okt = konlpy.tag.Okt()

sample_clean = re.sub(r'[^가-힣\s]', '', sample)
sample_token = Okt.morphs(sample_clean)

print(sample_token)

import konlpy.tag

Okt = konlpy.tag.Okt()

sample_clean = re.sub(r'[^가-힣\s]', '', sample)
sample_token = Okt.morphs(sample_clean)

print(sample_token)
['살', '키로', '남자', '아이', '구매', '했어요', '타이', '트', '하', '게', '잘', '맞아요', '무엇', '보다', '소재', '가', '너무', '좋네요', '세탁', '후', '에도', '보풀', '이', '안나', '고', '신축', '성도', '좋습니다', '기모', '라', '축구', '할', '때', '땀', '흘리며', '열심히', '뛰며', '공차', '네', '요']

# 3) 어간추출
# 먹었습니다 => 먹(어간) + 었 + 습니다
stem_result = Okt.morphs(sample_clean, stem=True) # 토큰화 + 어간추출 동시 진행

Okt.morphs(sample_clean, stem=True)
Out[48]: 
['살',
 '키로',
 '남자',
 '아이',
 '구매',
 '하다',
 '타이',
 '트',
 '하',
 '게',
 '자다',
 '맞다',
 '무엇',
 '보다',
 '소재',
 '가',
 '너무',
 '좋다',
 '세탁',
 '후',
 '에도',
 '보풀',
 '이',
 '안나',
 '고',
 '신축',
 '성도',
 '좋다',
 '기모',
 '라',
 '축구',
 '하다',
 '때',
 '땀',
 '흘리다',
 '열심히',
 '뛰다',
 '공차',
 '네',
 '요']

# 4) 품사태깅 : 품사(동사/명사/형용사 등) 확인 과정 => 조사를 제거(불용어 제거)
# 불용어를 태그한 뒤 삭제하기 위해서 진행하는 과정이다.
# (명사 : Noun, 조사 : Josa, 형용사 : Adjective, 부사 : Adverb 등)
pos_result = Okt.pos(sample_clean)

Okt.pos(sample_clean)
Out[50]: 
[('살', 'Noun'),
 ('키로', 'Suffix'),
 ('남자', 'Noun'),
 ('아이', 'Noun'),
 ('구매', 'Noun'),
 ('했어요', 'Verb'),
 ('타이', 'Noun'),
 ('트', 'Noun'),
 ('하', 'Suffix'),
 ('게', 'Josa'),
 ('잘', 'Verb'),
 ('맞아요', 'Verb'),
 ('무엇', 'Noun'),
 ('보다', 'Josa'),
 ('소재', 'Noun'),
 ('가', 'Josa'),
 ('너무', 'Adverb'),
 ('좋네요', 'Adjective'),
 ('세탁', 'Noun'),
 ('후', 'Noun'),
 ('에도', 'Josa'),
 ('보풀', 'Noun'),
 ('이', 'Josa'),
 ('안나', 'Noun'),
 ('고', 'Josa'),
 ('신축', 'Noun'),
 ('성도', 'Noun'),
 ('좋습니다', 'Adjective'),
 ('기모', 'Noun'),
 ('라', 'Josa'),
 ('축구', 'Noun'),
 ('할', 'Verb'),
 ('때', 'Noun'),
 ('땀', 'Noun'),
 ('흘리며', 'Verb'),
 ('열심히', 'Adverb'),
 ('뛰며', 'Verb'),
 ('공차', 'Noun'),
 ('네', 'Suffix'),
 ('요', 'Josa')]

# 조사 사전을 만들기 위한 작업

[ word for word, pos in pos_result if pos == 'Josa' ]

[ word for word, pos in pos_result if pos == 'Josa' ]
Out[55]: ['게', '보다', '가', '에도', '이', '고', '라', '요']

# *** 전체 리뷰(train)에 대한 형태소 분석
Josa = []             # 각 문장마다의 조사를 누적
stops = []            # 각 문장마다의 불용어 누적
train_token = []      # 각 문장마다의 토큰화(어간추출 적용)된 단어 누적

for vtext in train_x.values :
    vtext = Series(vtext).replace('[^가-힣 ]', '', regex=True)[0]           # 정제작업(한글과 공백이 아닌 모든 글자 제거)

    # 조사 수집(각 문장마다 조사를 수집)
    pos_result = Okt.pos(vtext)                                             # 품사태깅
    Josa = Josa + [ word for word, pos in pos_result if pos == 'Josa']      # 조사사전 생성

    # 토큰화 + 어간추출
    vtext = Okt.morphs(vtext, stem=True)

    # 불용어 사전 : 조사 + 한글자 글자 + 빈도수 1인 단어
    stops = stops + [word for word in vtext if len(word) == 1]              # 토큰화 된 단어 중 길이가 1인 단어 고르기

    # 토큰화 된 단어 저장(각 문장마다 수집 필요)
    train_token.append(vtext)


# 결과 확인
stops
Josa
train_token

# 4. 불용어 제거
# 1) 불용어 사전 생성 : 조사 + 한글자 단어 + 빈도수 1개인 단어
import numpy as np
all_train_words = [w for token in train_token for w in token ]                         # 모든 문장의 토큰화 결과 합치기
freq1_words = [word for word in all_train_words if all_train_words.count(word) == 1]   # 모든 문장에서 빈도수가 1인 단어만 골라내기

stops = np.unique(Josa + stops + freq1_words)                                          # 불용어 사전 생성
len(stops)

len(stops)
Out[71]: 15

# 2) 각 토큰화 된 결과에서 불용어 제거(train/test 각각 제거)
from numpy import nan as NA

def token_clean_func(text, stops) :
    result = []
    for vtext in text.values :
        vtext = Okt.morphs(vtext, stem=True)
        vtext = Series(vtext).replace('[^가-힣 ]', '', regex=True)
        vtext_rm = [word for word in vtext if word not in stops]                  # 불용어 제거
        vtext_rm = Series(vtext_rm).replace('',NA).dropna().to_list()             # 빈문자열 제거
        result.append(vtext_rm)
    return result

train_token = token_clean_func(train_x, stops)
test_token = token_clean_func(test_x, stops)

02 참고 : 최신 java 설치

# 1) 프로그램 다운로드 / 설치
# https://www.oracle.com/java/technologies/downloads/#jdk26-windows

# 2) 시스템 PATH 등록
# 검색창 > 시스템 환경 변수 > PATH 등록

# 3) 파이썬 PATH 등록
import os
os.environ['JAVA_HOME'] = r'C:\Program Files\Java\jdk-26.0.2'
print(os.environ.get('JAVA_HOME'))

03 쇼핑몰 후기 감성 분석 - 모델링(나이브베이즈)

# 나이브베이즈 모델
- 단어 기반으로 사후 확률을 계산
- 각 문장에서 각 단어가 서로 독립적이라고 가정 (실제로는 가정 성립 자체가 어려움) => 문맥 파악 어려움
- TF-IDF 변환으로 문장을 벡터화 -> 각 문장을 단어 빈도수 기반으로 숫자로 변경

** TF-IDF 변환
1) TF(Term Frequency) 변환
    - 단어의 빈도수에 가중치를 두고 각 단어가 얼마나 중요한지를 수치로 나타내는 작업

2) IDF(Inverse Document Frequency) 변환
    - 단어가 문서 전체에서 얼마나 희귀한가를 나타내는 작업

# 1. 데이터 로딩

# 2. 전처리
# 1) 정제
# 2) 토큰화 + 어간추출
# 3) 불용어 제거

len(train_token)
len(test_token)

len(train_token)
Out[75]: 7500

len(test_token)
Out[76]: 2500

# 3. TF-IDF 변환
# 1) 토큰화 -> 문장
' '.join(train_token[0])

train_join = [' '.join(token_list) for token_list in train_token]
test_join = [' '.join(token_list) for token_list in test_token]

# 2) TF-IDF 변환(불용어 제거 후 문장으로 변환하여 입력)
from sklearn.feature_extraction.text import TfidfVectorizer
m_tfidf = TfidfVectorizer()
train_x_tfidf = m_tfidf.fit_transform(train_join)
test_x_tfidf  = m_tfidf.transform(test_join)

# 4. 모델링 / 평가
import sklearn.naive_bayes
from sklearn.naive_bayes import MultinomialNB, CategoricalNB, BernoulliNB

# - MultinomialNB : 카운트 데이터에 적합
# - BernoulliNB : 이진 데이터 분류 적합
# - CategoricalNB : 다중 분류 적합

model = MultinomialNB()
model.fit(train_x_tfidf, train_y)

# 평가
model.score(train_x_tfidf, train_y)        # 0.8952
model.score(test_x_tfidf, test_y)          # 0.8588

model.predict_proba(test_x_tfidf[0])

# 5. 리뷰 테스트
test = '배송도 빠르고 실물이 너무 예뻐요 대만족입니다'
def f_review(text, model) :
    vtext = Series(text).replace('[^가-힣]','',regex=True)[0]
    vtest = Okt.morphs(vtext, stem=True)
    vtext = [word for word in vtext if word not in stops]
    vtext = ' '.join(vtext)
    test_tfidf = m_tfidf.transform([vtext])
    proba = model.predict_proba(test_tfidf)[0]
    print(f'긍정 확률 : {proba[1]}')


f_review('배송도 빠르고 실물이 너무 예뻐요 대만족입니다', model)
f_review('............')
f_review('')

import pandas as pd
from konlpy.tag import Okt

okt = Okt()

test = '배송도 빠르고 실물이 너무 예뻐요 대만족입니다'

def f_review(text, model):
    # 한글만 남기기
    vtext = pd.Series([text]).replace(
        r'[^가-힣\s]',
        '',
        regex=True
    ).iloc[0]

    # 형태소 분석
    tokens = okt.morphs(vtext, stem=True)

    # 불용어 제거
    tokens = [word for word in tokens if word not in stops]

    # TF-IDF 입력용 문자열로 변환
    clean_text = ' '.join(tokens)

    # 기존에 학습한 TF-IDF 객체로 변환
    test_tfidf = m_tfidf.transform([clean_text])

    # 긍정 확률 계산
    proba = model.predict_proba(test_tfidf)[0]

    print('전처리 결과:', clean_text)
    print(f'부정 확률: {proba[0]:.4f}')
    print(f'긍정 확률: {proba[1]:.4f}')

    return proba

f_review('배송도 빠르고 실물이 너무 예뻐요 대만족입니다', model)

f_review('배송도 빠르고 실물이 너무 예뻐요 대만족입니다', model)
전처리 결과: 배송 빠르다 실물 너무 예쁘다 대 만족 이다
부정 확률: 0.0884
긍정 확률: 0.9116
Out[128]: array([0.08844871, 0.91155129])

04 쇼핑몰 후기 감성 분석 - 모델링(RNN)

# 1. 데이터 로딩

# 2. 공통 전처리
# 1) 정제
# 2) 토큰화 + 어간추출
# 3) 불용어 제거
train_token
test_token

# 3. 벡터화
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

model_token = Tokenizer()
model_token.fit_on_texts(train_token)
model_token.word_index # 정수 인코딩 결과 ('마사지':999, '게임':1000)

model_token.word_index  # 정수 인코딩 결과 ('마사지':999, '게임':1000)
Out[141]: 
{'하다': 1,
 '좋다': 2,
 '에': 3,
 '너무': 4,
 '배송': 5,
 '은': 6,
 '자다': 7,
 '있다': 8,
 '같다': 9,
 '안': 10,
 ...

# 정수인코딩 룰에 의한 텍스트 변환
train_num = model_token.texts_to_sequences(train_token)
test_num = model_token.texts_to_sequences(test_token)

# 4. 패딩
# - 서로 길이가 다른 문장을 동일 길이로 맞추는 작업
# - padding size 결정
wc = [len(text_list) for text_list in train_token]

# ** 히스토그램 시각화 (문장 길이 분포 확인 목적)
import matplotlib.pyplot as plt
plt.hist(wc, bins=30)

* 제로 패딩 : 짧은 문장을 긴 문장의 길이에 맞추는 과정에서 짧은 문장의 뒷쪽을 0으로 채워 길이를 맞추는 작업

# ** 상위 95%를 커버하는 길이로 설정
import numpy as np
maxlen = int(np.percentile(wc, 95))

maxlen
Out[153]: 33

# 2) 패딩 변환
train_pad = pad_sequences(train_num, maxlen = maxlen)
test_pad = pad_sequences(test_num, maxlen = maxlen)

# 5. 모델링
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, Embedding
from tensorflow.keras.callbacks import EarlyStopping
import tensorflow as tf

# seed 고정
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 임베딩 차원 (hyper parameter)
# 2, 4, 8, 16, 32, 64, 128 등 결정
embedding_dim = 64
hidden_units = 128

# target 변수 변환
train_y_dm = pd.get_dummies(train_y).astype(int).values
test_y_dm = pd.get_dummies(test_y).astype(int).values

# 모델 생성
model_rnn = Sequential()
model_rnn.add(Embedding(word_cnt, embedding_dim))
model_rnn.add(SimpleRNN(hidden_units, activation = 'tanh'))
model_rnn.add(Dense(2, activation = 'softmax'))

model_rnn.compile('adam', loss='binary_crossentropy', metrics=['accuracy'])
es = EarlyStopping(monitor='val_loss', patience = 10, restore_best_weights = True)
model_rnn.fit(train_pad, train_y_dm, epochs=100, validation_split=0.25, batch_size = 32, callbacks = [es] )

# 모델 평가
model_rnn.evaluate(train_pad, train_y_dm)[1] # train accuracy
model_rnn.evaluate(test_pad, test_y_dm)[1] # test accuracy

model_rnn.evaluate(train_pad, train_y_dm)[1] # train accuracy
235/235 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9336 - loss: 0.1916 
Out[166]: 0.9336000084877014

model_rnn.evaluate(test_pad, test_y_dm)[1]   # test accuracy
79/79 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8596 - loss: 0.3522 
Out[167]: 0.8596000075340271

model_rnn.predict(train_pad[[0]])[0][1]

# 6. 리뷰 테스트
def f_review_rnn(text, model) :
    vtext = Series(text).replace('[^가-힣 ]', '', regex=True)[0]        # 정제
    vtext = Okt.morphs(vtext, stem=True) # 토큰화 + 어간추출
    vtext = [word for word in vtext if word not in stops]               # 불용어 제거

    train_pad = ......
    proba = model.predict(train_pad)
    print(f'긍정 확률 : {proba[1]}')

f_review_rnn('배송도 빠르고 실물이 너무 예뻐요 대만족입니다', model)
f_review_rnn('초등학생들이나 좋아하겠네요', model)
f_review_rnn('강의가 깔끔하네요... 근데 시험은 떨어진것같아요ㅜㅜㅜㅜㅜ ', model)

[골목길 탐지하기]_위성영상 탐색과 활용 : Sentinel-2

ecosso — Tue, 28 Jul 2026 18:24:08 +0900

중간 프로젝트를 진행하며 도로망 데이터에 대한 아쉬움을 매우 크게 느끼고 있었다.

이륜차 사고다발지역에 대한 특성이다보니 일반적인 승용차와 다르게 협소한 골목, 공원 내, 아파트 혹은 대학교 부지 내 도로 등에서도 사고가 발생한 지점이 있었는데, 분석에 활용한 도로망 데이터는 대부분 교통 네트워크 구축 혹은 행정 목적에 맞춰 제작된 데이터였기에 원하는 해상도에서의 생활도로까지는 충분히 표현되지 않은 경우가 존재했다.

서울시 내 생활도로, 좁은 골목까지 모두 도로를 새로 작도하기에는 시간적인 여유가 없었기에 도로 데이터가 존재하지 않는 사고 포인트도 10개 미만이었기에 인접 격자에서의 최솟값들을 가져와 대치하는 것으로 마무리했었던 기억이 있다.

그러던 중 딥러닝 수업을 들으며 문득 새로운 가능성이 떠올랐다.

기존 도로망 데이터에 중첩되는 곳이 도로로 학습된다는 가정 하에, CNN을 통해 해당 패턴에 부합하는 장소들을 찾게 된다면 미세도로망까지도 모두 탐지할 수 있지 않을까?라는 의문이었다.

즉, 학습된 모델이 도로의 형태를 인식해 자동으로 벡터 형태의 도로망을 생성하는 프로젝트이다.

해당 프로젝트를 위해서는 우선 고해상도 항공영상이 필요한 상황이다.

따라서 무료로 10m 급의 해상도까지 제공해주는 항공영상을 찾게 되었고, 해당 영상이 어떤 위성에서 어떤 목적으로 어떻게 촬영되었는지를 기본으로 이 프로젝트를 진행해보려고 한다.

(vworld가 훨씬 더 해상도가 높으나, 우선은 실험적으로 sentinel-2 영상을 고려하고 있다.)

01 CDSE

우선 CDSE (Copernicus Data Space Ecosystem)에서 위성영상을 무료로 다운받을 수 있다.

이는 유럽연합의 Copernicus 프로그램을 위하여 개발 및 운영되고 있는 공식 위성 데이터 플랫폼이며, 이 프로그램을 수행하기 위해 만든 위성들이 Sentinel 시리즈이다.

따라서 해당 페이지 내에서 Sentinel 영상들의 조회 및 다운로드가 가능하다.

또한 원하는 날짜, 구름량, 지역, 위성의 종류 등을 검색할 수 있으며 클라우드 내에서 NDVI 계산 등을 직접 수행할 수 있게 서비스가 제공되고 있다.

https://browser.dataspace.copernicus.eu/

Copernicus Browser

Search, visualise and download Sentinel satellite imagery

browser.dataspace.copernicus.eu

우선 Data & Information에 들어가 어떤 위성영상들을 다운로드 받을 수 있는지 살펴보았다.

1. Sentinel-1

Sentinel-1은 C-band SAR(Synthetic Aperture Radar) 센서를 탑재한 레이더 위성으로, 위성에서 직접 전자파를 발사하고 지표면에서 반사되어 돌아오는 신호를 수신하여 영상을 생성한다.

광학위성과 달리 태양광을 이용하지 않기 때문에 야간에도 촬영이 가능하며 구름, 비의 영향이 거의 없다. 따라서 육상 및 해양 모니터링을 위해서 주야간의 구분 없이 모든 기상 조건에서 지속적으로 관측이 가능하다.

주로 홍수 및 침수지역 탐지, 산림 변화 감지, 농경지 및 토양수분, 도시 변화, 지반침하 등을 확인하는데에 사용한다.

다만 표면에서 반사되어 오는 반사파를 측정하는 것이기에 표면의 거칠기, 구조물, 지형, 수분 함량 등을 측정할 수 있으나 콘크리트, 물과 같은 재료의 특성에서 오는 반사파가 다르다는 특성을 반영한 것이지, 색상에 의한 구분은 어렵다.

(레이더가 얼마나 강하게 반사되었는가를 색으로 표현하였을 뿐이다. 따라서 우리가 실제로 눈으로 보는 것과는 다른 색으로 표현된다.)

원래는 Sentinel-1A, Sentinel-1B 두 대의 위성이 운영되고 있었으나 1B의 이상으로 인해 2022년 임무가 종료된 상황이며, 2년 후인 2024년에 1C가 추가적으로 발사되어 현재 성능검증 중에 있다.

일반적으로 10m / 30m / 90m 세 가지의 해상도를 제공하고 있다.

2. Sentinel-2

Sentinel-2는 육상 관측을 위한 두 대의 위성으로 구성된 관측 시스템이다. 두 대의 위성이 180° 떨어진 위치에서 같은 궤도를 따라 운행하며 영상을 생성하며, 약 5일에 한 번씩 같은 장소를 촬영한다. 중위도의 경우에는 2-3일에 한 번씩 촬영하기 때문에 한국의 경우 해당 주기로 촬영이 가능하다. 현재 기존의 Sentinel-2A를 대신할 Sentinel-2C이 2024년 발사되어 현재는 총 3대의 위성이 동시에 운영중이다. (2C가 2A의 역할을 대신 수행중)

또한 Sentinel-2는 MSI (Multi-Spectral Instrument)라는 다중분광 카메라가 장착되어 있으며, 해당 카메라는 13개의 밴드를 촬영한다. (10m 밴드: 4개, 20m 밴드 : 6개, 60m 밴드 : 3개) 또한 지구를 촬영 시 각 타일은 110 X 110 ㎞ 크기의 정사각형 타일로 나누어 저장한다.

Sentinel-2의 Level 1C, 1B의 경우 센서가 측정한 원시 데이터와 대기 상단 반사율(TOA) 데이터로써 주로 위성영상의 전처리, 보정 등에 사용된다. 아직 대기의 영향을 제거하지 않은 영상으로 일반적인 토지피복 분류에 사용되는 영상이라기보다는 영상 전처리 및 알고리즘 개발에 주로 활용된다.

Sentinel-2의 Level 2A의 경우 Level 1C에서부터 생성된 대기보정 지표반사율 영상을 제거한다. 이는 구름, 수증기, 대기의 반사 및 산란 등에 대한 보정을 진행한 영상이다. 따라서 에어로졸 광학두께(AOT : Aerosol Optical Thickness), 수증기 (WV : Water Vapour), 장면분류 (SCL : Scence Classification) 등 역시 추가적인 영상도 Level 2A에 포함된다. 이러한 영상 산출물 및 분광 밴드별 지표반사율 자료는 각각 10m, 20, 60m의 해상도로 제공된다.

- Sentinel-2 Level 2A WorldCover Annual Cloudless Mosaic (RGBNIR)

연간 무운 모자이크로, 해당 합성영상은 전 지구 규모의 구름 없는 10m 해상도 분석용 모자이크이다. 2020~2021년의 연간 Sentinel-2 아카이브로부터 생성되었으며, 각 밴드의 연간 시계열 자료에서 구름 픽셀을 제거한 뒤, 남은 값들의 중앙값을 계산하여 제작되었다.

RGBNIR 모자이크는 다음과 같은 10m 밴드를 포함한다. : B04(Red), B03(Green), B02(Blue), B08(Near Infrared)

COG (Cloud Optimized GeoTIFF) 형식으로 제공되며, Copernicus Broweser에서 확인 가능하다.

3. Sentinel-3

Sentinel-3는 해양 및 육상 표면의 색상, 해수면 및 지표면 온도, 해수면 지형을 높은 정확도로 측정하여 해양 예측, 환경 모니터링, 기후 변화 모니터링 등을 수행하기 위한 영상을 지원한다. 기존 ERS, ENVISAT, SPOT Vegetaion 위성들이 관측하던 자료를 이어받으며 센서 성능 및 관측 범위를 더욱 향상시키기 위해 개발되었다.

> ERS(European Remote Sensing Satellite): ESA가 운영한 유럽 최초의 본격적인 지구관측 위성 시리즈로, 레이더를 이용해 해양·빙하·육지와 지표 변화를 관측 >

ENVISAT(Environmental Satellite):

ERS의 후속 대형 환경관측 위성으로, 레이더와 광학·대기 센서를 함께 탑재해 해양, 육상, 대기, 기후를 종합적으로 관측

> SPOT Vegetation:

프랑스 SPOT 위성에 탑재된 광역 식생 관측 센서로, 전 세계 식생 분포와 생육 상태, 토지피복 변화를 지속적으로 모니터링

Sentinel-3의 경우 OLCI Level-1, OLCI Level-2가 있는데, Level-1은 OLCI(Ocean and Land Colour Instrument) 센서에서 취득한 자료를 방사보정 (센서 오차를 보정), 위치보정 (영상을 실제 위치에 맞추는 보정), 정사보정 (지형 왜곡을 보정)하며, Level-2는 Level-1 자료를 이용하여 계산한 지구물리학적 변수를 제공한다. Level -2는 육상 환경 변수, 대기 환경 변수, Full Resolution 및 Reduced Resolution 자료, 데이터 품질 플래그, 대기보정 정보 등을 포함한다.

또한 SLSTR Level-1, Level-2의 경우 Level-1은 주요 물리량, Level-2는 Level-1보다 높은 수준의 지구물리학적 정보를 제공한다.

SYN Level-2의 경우 OLCL와 SLSTR 센서의 Level-1 및 Level-2를 결합하여 생성되었으며 대기 및 대기 구성성문에 대한 정보를 제공한다.

SRAL Level-1, Level-2의 경우 마찬가지로 SRAL의 원시데이터를 보정 및 검증한 기본 처리 자료, 해당 기본 처리 자료를 기반으로 추가 처리하여 생성한 지구물리학 제품이다. 해수면 높이, 유의파고, 풍속 등에 대한 정보를 제공한다.

POD는 위성의 궤도를 매우 높은 정확도로 계산한 보조 데이터로, NRT, STC, NTC 등에 대한 정보를 제공한다.

4. Sentinel-5P

Sentinel-5P는 대기 관측을 전담하는 위성이다. 주요 목적은 높은 시공간적 해상도로 대기를 관측하여 대기질, 오존 및 자외선 관측, 기후 모니터링 및 예측 등에 대한 정보를 지원하는 것이다. TROPOMI(TROPOspheric Monitoring Instrument) 센서를 탑재하고 있으며 처리 수준에 따라 Level-0, 1B, 2 제품을 제공한다.

Sentinel-5P Level 2의 경우 여러가지 항목에 대한 정보를 제공한다. :

- 에어로졸 지수 또는 흡수성 에어로졸 지수 : 이는 황사, 산불 연기, 화산재 등에 활용

- 일산화탄소 : 대기오염, 산불 영향, 배출원 분석 등에 활용

- 구름 : 대기 보정, 기후 연구, 복사전달 연구 등에 활용

- 포름알데히드 : 광화학 스모그, VOC (휘발성유기화합물) 연구, 대기화학 연구 등에 활용

- 메탄 : 기후변화 연구, 메탄 배출원 분석, 온실가스 감시, 환경정책 수립 등에 활용

- 이산화질소 : 대기오염, 도시환경 분석, 산업활동 모니터링 등에 활용

- 오존 : 오존층 감소 모니터링, 극지방 오존홀 연구, 대기질 평가, 오존 오염 관리 등에 활용

- 이산화황 : 화산활동 감시, 대기오염, 대기화학 연구, 인체 건강 영향 평가 등에 활용

5. Sentinel-6

Sentinel-6은 평균 해수면 및 해양 상태와 같은 해양 환경 관측 목적으로 운용되는 두 개의 위성이다. Poseidon-4 SAR 고도계, AMR-C (기후연구용 다중주파수 마이크로파 복사계), POD(정밀 궤도 결정 시스템) 등의 센서가 탑재되어 있다.

Sentinel-6의 경우 크게 3개의 주요 데이터 제품을 제공한다. :

- Level-1 : Poseidon-4 고도계에서 관측한 원시 신호를 보정하여 거리, 파형 등의 기본 관측값을 제공

- Level-2 : Level-1 자료를 추가 처리하여 해수면 높이, 유의파고, 해상풍속 등 실제 해양 분석에 활용할 수 있는 지구물리학적 변수를 제공

- 보조자료(Auxiliary Data) : 위성의 정밀 궤도, 기상 및 대기 보정 등 Level-1과 Level-2 자료를 정확하게 처리하기 위해 필요한 보조 정보를 제공

Sentinel 시리즈를 살펴본 결과, 이번 도로 탐지 실험에는 Sentinel-2가 가장 적합하다고 판단하였다.

Sentinel-1은 기상과 주야간에 관계없이 관측할 수 있다는 장점이 있지만 SAR 영상이므로 일반적인 항공사진과 영상 특성이 크게 다르다. Sentinel-3와 Sentinel-6은 해양 및 광역 환경관측, Sentinel-5P는 대기환경 관측을 주요 목적으로 하기 때문에 도로와 같은 육상의 세부 객체를 영상에서 구분하려는 이번 목적과는 차이가 있다.

반면 Sentinel-2는 육상 관측을 목적으로 하는 광학위성이며, 가시광선 RGB와 근적외선(NIR)을 포함한 다양한 분광 정보를 제공한다. 특히 B02(Blue), B03(Green), B04(Red), B08(NIR) 밴드는 10m 공간해상도로 제공되므로 Sentinel 시리즈 가운데 육상의 도로, 건물, 식생 등 지표면의 공간적 패턴을 구분하는 데 비교적 적합하다.

이번 프로젝트에서 가장 중요하게 생각한 점은 기존 도로망에 포함된 도로의 영상 패턴을 학습한 모델이 기존 데이터에 존재하지 않는 도로까지 찾아낼 수 있는가이다.

따라서 우선 기존 도로망을 Sentinel-2 영상과 중첩하여 도로에 해당하는 영역을 학습 라벨로 구축하고, CNN 기반 이미지 분할 모델을 통해 영상에서 도로와 유사한 공간적·분광적 특징을 갖는 영역을 탐지해보고자 하였다.

다만 Sentinel-2의 최고 공간해상도는 10m이므로 이번 프로젝트의 궁극적인 목표인 협소한 생활도로와 골목길을 정밀하게 구분하기에는 한계가 있을 것으로 예상된다. 폭이 10m보다 좁은 도로는 하나의 픽셀 안에 건물, 식생, 도로 등이 함께 포함될 수 있기 때문이다.

따라서 Sentinel-2는 최종 도로망 구축을 위한 데이터라기보다, 공개 위성영상과 기존 도로 데이터를 이용해 딥러닝 기반 도로 탐지가 가능한지 확인하기 위한 초기 실험 데이터로 활용하고자 한다.

이후 실험에서 공간해상도의 한계가 확인될 경우, 보다 고해상도의 정사영상이나 항공영상을 이용하여 동일한 방법을 적용하고 결과를 비교할 예정이다.

+) 이후 학습을 위한 전국 표준 노드링크 데이터는 위성사진 촬영 직전의 가장 최근 날짜인 2026년 06월 12일 데이터를 사용하였다.

전국표준노드링크 | ITS 국가교통정보센터(National Transport Information Center)

ITS 국가교통정보센터

its.go.kr

+) 실험 결과 :

실제로 Sentinel-2 영상과 표준노드링크를 이용하여 도로 탐지를 시도한 결과, 예상했던 것처럼 학습 데이터와 영상 해상도 양쪽에서 한계가 나타났다.

우선 정답 데이터로 사용한 표준노드링크에는 주요 도로는 비교적 잘 구축되어 있었지만, 이번 프로젝트에서 탐지하고자 했던 좁은 골목길과 생활도로가 모두 포함되어 있지는 않았다. 기존 도로망과 중첩되는 영상의 특징을 도로로 학습시키는 방식이므로, 애초에 정답 데이터에 포함되지 않은 골목길의 시각적 특징은 모델이 충분히 학습하기 어려웠다.

여기에 Sentinel-2의 10m 공간해상도도 문제가 되었다. 실제 영상을 확대해보면 광폭도로는 어느 정도 형태를 확인할 수 있었지만, 좁은 골목길은 하나의 픽셀보다 폭이 작거나 주변의 건물·식생·그림자 등과 함께 하나의 픽셀에 포함되는 경우가 많았다.

따라서 도로와 비도로의 경계가 육안으로도 명확하게 구분되지 않았으며, 모델 역시 이러한 협소도로를 안정적으로 탐지하지 못했다.

결과적으로 초기 실험에서는 주요 도로는 어느 정도 탐지할 수 있었지만, 본래 목표로 했던 골목길과 생활도로를 새롭게 찾아내는 데에는 뚜렷한 한계가 있었다. 이는 단순히 모델의 성능 문제라기보다, 학습에 사용한 기존 도로망에 미세도로가 충분히 포함되지 않았다는 점과 입력 영상의 공간해상도가 목표 객체의 크기에 비해 낮다는 점이 함께 작용한 결과로 판단하였다.

따라서 모델 구조나 학습 조건을 계속 조정하기보다는 입력 데이터와 정답 데이터 자체를 개선하는 것이 우선이라고 판단하였다. 이후에는 국토정보플랫폼에서 제공하는 항공정사영상 등 보다 고해상도의 영상을 확보하여 실제 골목길의 형태와 경계를 식별할 수 있도록 하고, 미세도로를 보다 정확하게 반영할 수 있는 정답 데이터를 함께 구축하여 도로 탐지 실험을 다시 진행하고자 하였다.

결과적으로 Sentinel-2를 이용한 이번 실험은 원하는 수준의 골목길 탐지에는 도달하지 못했지만, 딥러닝 기반 미세도로 탐지에서는 모델의 선택만큼이나 입력 영상의 공간해상도와 정답 라벨의 품질이 중요하다는 점을 확인하는 계기가 되었다.

#4 4일차_CNN, 얼굴 사진 분류하기, 쇼핑몰 후기 감성 분석

ecosso — Tue, 28 Jul 2026 16:06:53 +0900

01 CNN (컨볼루션 신경망)

02 유명인사의 얼굴 데이터 분류하기

-01 이미지 분석 - pca + knn (얼굴 데이터)

-02 이미지 분석 - ANN(3차원 학습 불가) (얼굴 데이터)

-03 이미지 분석 - CNN(3차원 학습 가능) (얼굴 데이터)

-04 새로운 얼굴 사진 예측 함수

-05 사전학습 모델(EfficientNetB0) + 얼굴 데이터 전이학습

03 쇼핑몰 후기 감성 분석

01 CNN (컨볼루션 신경망)

- 심층신경망에 컨볼루션 망을 추가한 신경망

- 컨볼루션 망에서 이미지의 정교한 특징을 추출

- 마스크(=필터=윈도우)에 의해서 재추출된 신호

- hyper parameter : 컨볼루션층 수, 마스크 수, 마스크 사이즈

- parameter : 각 마스크 가중치

- 풀링(=서브샘플링) : 기존 이미지 신호 중 일부를 추출하여 보다 단순한 맵으로 결정 -> 과적합 해소

pool_size는 (2,2), (3,3), (4,4) 등을 사용 <- hyper marameter

pool에 의해 추출되는 신호는 주로 최댓값(max pooling), 평균값(average pooling) 등

- Dropout : 의도적으로 특정 층의 중요하지 않은 노드(뉴런=Unit)를 꺼버리는 기법 -> 과적합 해소

size는 보통 0.5, 0.25 등을 주로 사용 <- hyper parameter

02 유명인사의 얼굴 데이터 분류하기

-01 이미지 분석 - pca + knn (얼굴 데이터)

1) 데이터 로딩
from sklearn.datasets import fetch_lfw_people
import numpy as np

people = fetch_lfw_people(min_faces_per_person=50, resize=0.7) # 스케일링 된 데이터
X = people['data']
X_images = people['images']
y = people['target']
yname = people['target_names']
n_classes = len(yname)

# 데이터 확인
import matplotlib.pyplot as plt
X_images[0].shape

X_images[0].shape
Out[159]: (87, 65)

plt.imshow(X_images[1], cmap='gray')
yname[y[1]]

2) 데이터 분리
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X, y, random_state=0, stratify=y)

3) 모델링
# 1) knn
from sklearn.neighbors import KNeighborsClassifier
m_knn = KNeighborsClassifier()
m_knn.fit(train_x, train_y)
m_knn.score(train_x, train_y)      # 0.6863
m_knn.score(test_x, test_y)        # 0.4974

# 2) pca + knn
from sklearn.decomposition import PCA
from sklearn.pipeline import make_pipeline

pipe = make_pipeline(PCA(100), KNeighborsClassifier(5))
pipe.fit(train_x, train_y)
pipe.score(train_x, train_y)       # 0.6965
pipe.score(test_x, test_y)         # 0.4974

-02 이미지 분석 - ANN(3차원 학습 불가) (얼굴 데이터)
1) 데이터 로딩
from sklearn.datasets import fetch_lfw_people
import numpy as np

people = fetch_lfw_people(min_faces_per_person=50, resize=0.7)
X = people['data']
X_images = people['images']
y = people['target']
yname = people['target_names']
n_classes = len(yname)

2) 데이터 분리
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X, y, random_state=0, stratify=y)

# 원핫 인코딩
import pandas as pd
train_y10 = pd.get_dummies(train_y, prefix='Y').astype(int).values
test_y10 = pd.get_dummies(test_y, prefix='Y').astype(int).values

3) 모델링
# 1) seed 고정
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input, Dense
from keras import Sequential

model = Sequential()
model.add(Input(shape=(train_x.shape[1], )))
model.add(Dense(392, activation='relu'))
model.add(Dense(196, activation='relu'))
model.add(Dense(98, activation='relu'))
model.add(Dense(n_classes, activation='softmax'))

# 3) 오차함수, 최적화 결정
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)

# 5) 학습
hist = model.fit(train_x, train_y10, validation_split=0.25,
                  batch_size=10, epochs=50000, callbacks=[es])

# 6) 평가
model.evaluate(train_x, train_y10)[1]    # 0.6871
model.evaluate(test_x, test_y10)[1]      # 0.5948

acc = hist.history['accuracy']
plt.plot(range(1, len(acc)+1), hist.history['accuracy'], label='train')
plt.plot(range(1, len(acc)+1), hist.history['val_accuracy'], label='val')
plt.legend()
plt.xticks(range(1, len(acc)+1))

-03 이미지 분석 - CNN(3차원 학습 가능) (얼굴 데이터)
1) 데이터 로딩
from sklearn.datasets import fetch_lfw_people
import numpy as np

people = fetch_lfw_people(min_faces_per_person=50, resize=0.7)
X = people['data']
X_images = people['images']
y = people['target']
yname = people['target_names']
n_classes = len(yname)
h, w = X_images.shape[1], X_images.shape[2]

2) 데이터 분리 및 변환
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X_images, y, random_state=0, stratify=y)

# ** Conv2D 층은 (높이, 너비, 채널) 형태 요구 (흑백 -> 채널:1)
train_x = train_x.reshape((train_x.shape[0], h, w, 1))
test_x = test_x.reshape((test_x.shape[0], h, w, 1))

import pandas as pd
train_y10 = pd.get_dummies(train_y).astype(int).values
test_y10 = pd.get_dummies(test_y).astype(int).values

3) 모델링
# 1) seed 고정
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input, Dense, Conv2D, Dropout, Flatten, MaxPooling2D
from keras import Sequential

model = Sequential()
model.add(Input(shape=(h, w, 1)))
model.add(Conv2D(32, kernel_size=(2, 2), activation='relu'))
model.add(Conv2D(32, kernel_size=(2, 2), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_classes, activation='softmax'))

# 3) compile
model.compile('adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) 정지규칙
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)

# 5) 학습
hist = model.fit(train_x, train_y10, validation_split=0.25,
                  batch_size=10, epochs=50000, callbacks=[es])

# 6) 평가
model.evaluate(train_x, train_y10)[1]    # 0.9393
model.evaluate(test_x, test_y10)[1]      # 0.7051

acc = hist.history['accuracy']
plt.plot(range(1, len(acc)+1), hist.history['accuracy'], label='train')
plt.plot(range(1, len(acc)+1), hist.history['val_accuracy'], label='val')
plt.legend()
plt.xticks(range(1, len(acc)+1))

-04 새로운 얼굴 사진 예측 함수

# 데이터 경로에 다음 사진을 넣어준다.

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['font.family'] = 'Malgun Gothic' # Windows
plt.rcParams['axes.unicode_minus'] = False # 마이너스 기호 깨짐 방지

def f_predict_face(img_path, model, h, w, yname, X_images, y):

    # 1) 이미지 로딩 및 흑백 변환
    img = Image.open(img_path).convert('L')          # 흑백(그레이스케일) 변환

    # 2) 크기 맞추기 (학습 데이터와 동일한 h, w)
    img = img.resize((w, h))                         # PIL은 (width, height) 순서

    # 3) 배열 변환 및 스케일링 (0~255 -> 0~1)
    img_arr = np.array(img) / 255.0

    # 4) CNN 입력 형태로 변환 (1, h, w, 1)
    img_input = img_arr.reshape((1, h, w, 1))

    # 5) 예측
    pred = model.predict(img_input)
    pred_class = pred.argmax(axis=1)[0]
    pred_name = yname[pred_class]
    pred_prob = pred[0][pred_class]

    print(f"예측 인물: {pred_name}, 확률: {pred_prob:.4f}")

    # 6) 입력 사진 vs 예측된 클래스의 실제 사진 비교 출력
    real_img = X_images[y == pred_class][0]           # 예측 클래스의 실제 이미지 하나 추출

    fig, ax = plt.subplots(1, 2)
    ax[0].imshow(img_arr, cmap='gray')
    ax[0].set_title('입력 사진')
    ax[0].axis('off')

    ax[1].imshow(real_img, cmap='gray')
    ax[1].set_title(f'예측: {pred_name}')
    ax[1].axis('off')

# 사용 예시
f_predict_face('image_sample.jpg', model, h, w, yname, X_images, y)

f_predict_face('image_sample.jpg', model, h, w, yname, X_images, y)
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 60ms/step
예측 인물: Junichiro Koizumi, 확률: 0.7375

-05 사전학습 모델(EfficientNetB0) + 얼굴 데이터 전이학습

1) 데이터 로딩 (컬러로 로드해야 사전학습 모델 입력에 맞음)
from sklearn.datasets import fetch_lfw_people
import numpy as np

people = fetch_lfw_people(min_faces_per_person=50, resize=0.7, color=True)
X_images = people['images'] # (n, h, w, 3)
y = people['target']
yname = people['target_names']
n_classes = len(yname)

h, w = X_images.shape[1], X_images.shape[2]

2) 데이터 분리
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X_images, y, random_state=0, stratify=y)

3) 사전학습 모델 입력 크기(224x224)로 리사이즈
import tensorflow as tf

def resize_batch(x, size=(224, 224)):
    x = tf.image.resize(x, size)
    return x.numpy()

train_x_rs = resize_batch(train_x)
test_x_rs  = resize_batch(test_x)

# EfficientNet은 0~255 입력을 받아 내부적으로 전처리하므로 /255 하지 않음
# (fetch_lfw_people은 0~1로 스케일링되어 있으므로 되돌려줌)
train_x_rs = train_x_rs * 255
test_x_rs  = test_x_rs * 255

# 원핫 인코딩
import pandas as pd
train_y10 = pd.get_dummies(train_y).astype(int).values
test_y10  = pd.get_dummies(test_y).astype(int).values

4) 사전학습 모델 로딩 (특성 추출기로 사용, 가중치 고정)
from tensorflow.keras.applications import EfficientNetB0
from tensorflow.keras.layers import Input, Dense, Dropout, GlobalAveragePooling2D
from tensorflow.keras.models import Model

base_model = EfficientNetB0(include_top=False,           # ImageNet 1000개 클래스용 마지막 분류층을 빼고, 출력층을 새로 붙이겠다는 옵션
                            weights='imagenet',          # 이미지 분류 연구용으로 만든 대규모 데이터셋(1,000개 클래스, 약 120만 장)
                            input_shape=(224, 224, 3))   # ImageNet 학습 크기이므로 사용 권장(변경가능)
base_model.trainable = False                             # 사전학습 가중치 고정 (feature extractor로만 사용)

# 모델 생성(base_model 자체가 이미 완성된 하나의 모델이므로 Sequential 방식 사용 불가 -> Functional API 방식 사용)
# Functional API : 각 층을 함수처럼 다루면서 입력과 출력을 직접 연결하는 방식
inputs = Input(shape=(224, 224, 3))
x = base_model(inputs, training=False)
x = GlobalAveragePooling2D()(x)
x = Dense(128, activation='relu')(x)
x = Dropout(0.5)(x)
outputs = Dense(n_classes, activation='softmax')(x)      # 얼굴 데이터 출력 층 연결

model = Model(inputs, outputs)
model.compile('adam', loss='categorical_crossentropy', metrics=['accuracy'])

5) 학습
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)

hist = model.fit(train_x_rs, train_y10, validation_split=0.25,
batch_size=16, epochs=50, callbacks=[es])

6) 평가
model.evaluate(train_x_rs, train_y10)[1] # 0.9820
model.evaluate(test_x_rs, test_y10)[1] # 0.9102

03 쇼핑몰 후기 감성 분석

import pandas as pd
df = pd.read_table('shopping_ratings_total.txt', names = ['ratings', 'reviews'])
df.head()

df.head()
Out[328]: 
   ratings                                            reviews
0        5                                            배공빠르고 굿
1        2                      택배가 엉망이네용 저희집 밑에층에 말도없이 놔두고가고
2        5  아주좋아요 바지 정말 좋아서2개 더 구매했어요 이가격에 대박입니다. 바느질이 조금 ...
3        2  선물용으로 빨리 받아서 전달했어야 하는 상품이었는데 머그컵만 와서 당황했습니다. 전...
4        5                  민트색상 예뻐요. 옆 손잡이는 거는 용도로도 사용되네요 ㅎㅎ
...

df.shape

df.shape
Out[329]: (200000, 2)

2) target 변수 변환 (평점 -> 이진데이터)
import numpy as np
np.unique(df['ratings'])

np.unique(df['ratings'])
Out[6]: array([1, 2, 4, 5])

3) 샘플링
# 실제 분석 과정에서는 생략한다.
# 금일 실습에서는 20만건 학습이 불가능한 상황이기 때문에 3만건만 우선 랜덤샘플링을 진행한다.

df = df.sample(n=30000, random_state=0).reset_index(drop=True) # 랜덤 샘플링이기 때문에 index를 초기화한다.

4) 데이터 분리 (train/test)
from sklearn.model_selection import train_test_split
train_test_aplit(df['reviews'], df['ratings'], random_state=0, stratify=df['ratings'])

5) 전처리 (정제 -> 형태소 분석)
# pip install konlpy
import konlpy.tag
Okt = konlpy.tag.Okt() # RuntimeError: Java versioin too old. Java 9 or later is required
# cmd에서 java -version

# ** java 최신버전 설치
# https://www.oracle.com/java/technologies/downloads/#jdk26-windows
# 설치 후 명령 프롬포트는 다시 실행한 다음에 버전확인이 적용된다.
# 이후 path 등록을 진행해야 한다. (시스템 환경 변수 편집 - 환경 변수 - path - 다운로드 받은 C:\Program Files\Java\jdk-26.0.2\bin 추가 후 확인)

#3 3일차_ANN(다중 분류), 이미지 분석(PCA+KNN, ANN, CNN)

ecosso — Mon, 27 Jul 2026 16:22:48 +0900

01 ANN - 다중 분류

02 PCA + KNN 모델을 이용한 이미지 분석

03 ANN 모델을 사용한 이미지 분석

04 CNN 모델을 사용한 이미지 분석

01 ann - 다중 분류

1) 데이터 로딩

from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target
X.shape
y.shape

X.shape
Out[4]: (150, 4)

y.shape
Out[5]: (150,)

# target 변수 원핫 인코딩 (3개 클래스)
import pandas as pd
y3 = pd.get_dummies(y, prefix='Y').astype('int')

pd.get_dummies(y, prefix='Y').astype('int')
Out[9]: 
     Y_0  Y_1  Y_2
0      1    0    0
1      1    0    0
2      1    0    0
3      1    0    0
4      1    0    0
..   ...  ...  ...
145    0    0    1
146    0    0    1
147    0    0    1
148    0    0    1
149    0    0    1

[150 rows x 3 columns]

2) 스케일링

from sklearn.preprocessing import StandardScaler, MinMaxScaler
m_sc = MinMaxScaler()
X_sc = m_sc.fit_transform(X)

3) 데이터 분리

from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X, y, random_state=0, stratify=y)

4) 모델링

# 1) seed 고정
import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Input(shape=(train_x.shape[1], )))
model.add(Dense(2, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# 3) 오차함수, 최적화 결정
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights = True)

# 5) 학습
hist = model.fit(train_x, train_y, validation_split=0.25,
                 batch_size = 10, epochs=50000, callbacks=[es])

Epoch 1/50000
C:\Users\itwill\anaconda3\Lib\site-packages\keras\src\losses\losses.py:34: SyntaxWarning: In loss categorical_crossentropy, expected y_pred.shape to be (batch_size, num_classes) with num_classes > 1. Received: y_pred.shape=(None, 1). Consider using 'binary_crossentropy' if you only have 2 classes.
  return self.fn(y_true, y_pred, **self._fn_kwargs)
9/9 ━━━━━━━━━━━━━━━━━━━━ 1s 23ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 2/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 3/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 4/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 5/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 6/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 7/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 8/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 9/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 10/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00
Epoch 11/50000
9/9 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - accuracy: 0.3571 - loss: 0.0000e+00 - val_accuracy: 0.2500 - val_loss: 0.0000e+00

# 1. 데이터 로딩
from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target
X.shape
y.shape

# target 변수 원핫 인코딩(3개 클래스)
import pandas as pd
y3 = pd.get_dummies(y, prefix='Y').astype('int')

# 2. 스케일링
from sklearn.preprocessing import StandardScaler, MinMaxScaler
m_sc = MinMaxScaler()
X_sc = m_sc.fit_transform(X)

# 3. 데이터 분리
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y, train_y3, test_y3 = train_test_split(X, y, y3, random_state=0, stratify=y)

# 4. 모델링
# 1) seed 고정
import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Input(shape=(train_x.shape[1], )))
model.add(Dense(2, activation='relu'))
model.add(Dense(3, activation='softmax'))             # 다중분류일때 출력층 활성함수는 sigmoid 또는 softmax 적합

# 3) 오차함수, 최적화 결정
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights = True)

# 5) 학습
hist = model.fit(train_x, train_y3, validation_split=0.25,
                 batch_size = 10, epochs=50000, callbacks=[es])

02 PCA + KNN 모델을 이용한 이미지 분석

이미지는 비정형데이터이므로, 우선 분석을 위해서는 정형데이터처럼 컴퓨터가 인식가능한 형태로 변형되어야 한다.

이미지 데이터는 픽셀로 나누어져 있으며 각 픽셀은 RGB 코드에 의해 0~255의 값을 각각 가지게 된다.

예를 들어 4 X 5의 해상도를 가지는 파일의 경우, 20개의 픽셀을 가지게 된다.

즉, 20개의 열이 생성된다.

PCA 또는 KNN과 같은 머신러닝 모델은 일반적으로 2차원 표 형태의 입력을 사용하기 때문에 위와 같은 과정을 통해 이미지 한 장의 높이 X 너비 배열을 하나의 긴 벡터로 펼치는 작업이 필요하다. 이를 flatten이라고 한다.

즉, 이미지 한 장이 1차원 벡터로 펼쳐지며 전체 이미지 데이터셋이 2차원 표가 된다.

이미지를 flatten하는 과정에서 픽셀 하나하나가 변수가 되므로 해상도에 따라 변수의 수가 매우 많아지게 되는데, 이 과정에서 계산량 증가, 거리 계산의 의미가 약해지는 차원의 저주 등 여러가지 문제가 발생하게 된다.

따라서 PCA를 통해 데이터의 분산을 최대한 많이 설명할 수 있는 새로운 축인 주성분을 만들게 된다.

이는 여러 픽셀값을 선형적으로 조합하여 이미지 사이의 주요 변화 패턴을 나타내는 축을 찾는 과정이다.

=> PCA는 가장 큰 분산을 설명하는 주성분을 만들어줌으로써, 특정 픽셀의 변동이 심한 사진의 유사성을 판별/분류할 수 있게 도와준다.

PCA로 차원을 축소한 이후에는 각 이미지가 몇 개의 주성분 점수로 표현되며, KNN을 통해 새로운 이미지와 기존 학습 이미지 사이에서 가까운 학습 이미지들을 찾아 주변 이웃이 가장 많이 속한 클래스로 분류한다.

그러나 차원 압축 / 분류 등을 통해 원래 이미지가 가지고 있던 픽셀들의 신호가 약해지는 경향을 보완하기 위하여 이 neural network를 통한 학습/분류가 이후에 발전하게 된다.

# 1) 데이터 로딩 (RGB로 변환된 데이터)
from tensorflow.keras.datasets import mnist
(train_x, train_y), (test_x, test_y) = mnist.load_data() # mnist는 train / test가 사전에 나누어져 있다.

(train_x, train_y), (test_x, test_y) = mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11490434/11490434 ━━━━━━━━━━━━━━━━━━━━ 1s 0us/step

train_x.shape

# 층 6만개, 28 X 28의 해상도

train_x.shape
Out[132]: (60000, 28, 28)

train_y

train_y
Out[134]: array([5, 0, 4, ..., 5, 6, 8], shape=(60000,), dtype=uint8)

import numpy as np
np.unique(train_y)

# 숫자 손글씨이기 때문에 0~9의 값을 가진다.

np.unique(train_y)
Out[136]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)

# 데이터 확인

import matplotlib.pyplot as plt

첫 번째 사진의 값을 확인해본다.

28 X 28 의 해상도를 가지고 있다.

train_x[0].shape

train_x[0].shape
Out[138]: (28, 28)

이미 RGB 변환이 완료되었기에 2차원의 형태로 출력된다.

train_x[0]

train_x[0]
Out[137]: 
array([[  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,
         18,  18,  18, 126, 136, 175,  26, 166, 255, 247, 127,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,  30,  36,  94, 154, 170,
        253, 253, 253, 253, 253, 225, 172, 253, 242, 195,  64,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,  49, 238, 253, 253, 253, 253,
        253, 253, 253, 253, 251,  93,  82,  82,  56,  39,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,  18, 219, 253, 253, 253, 253,
        253, 198, 182, 247, 241,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,  80, 156, 107, 253, 253,
        205,  11,   0,  43, 154,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,  14,   1, 154, 253,
         90,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 139, 253,
        190,   2,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  11, 190,
        253,  70,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  35,
        241, 225, 160, 108,   1,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         81, 240, 253, 253, 119,  25,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,  45, 186, 253, 253, 150,  27,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,  16,  93, 252, 253, 187,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0, 249, 253, 249,  64,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,  46, 130, 183, 253, 253, 207,   2,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  39,
        148, 229, 253, 253, 253, 250, 182,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  24, 114, 221,
        253, 253, 253, 253, 201,  78,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,  23,  66, 213, 253, 253,
        253, 253, 198,  81,   2,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,  18, 171, 219, 253, 253, 253, 253,
        195,  80,   9,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,  55, 172, 226, 253, 253, 253, 253, 244, 133,
         11,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0, 136, 253, 253, 253, 212, 135, 132,  16,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0],
       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
          0,   0]], dtype=uint8)

plt.imshow(train_x[0])

원본 데이터를 확인할 수 있다.

# 위 이미지의 실제 정답 찾기

train_y[0]

train_y[0]
Out[142]: np.uint8(5)

2) 데이터 변환

train_x.reshape(60000, -1) # 28 * 28 로 펼쳐짐 (flatten)

train_x.reshape(60000, -1)
Out[143]: 
array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], shape=(60000, 784), dtype=uint8)

train_x.reshape(60000, -1) / 255 # 0~255 => 0~1의 범위로 변환

MinMaxScaling과 같은 scaling 효과를 낸다.

train_x_sc = train_x.reshape(60000, -1) / 255
test_x_sc = test_x.reshape(10000, -1) / 255 # test는 1만건

3) 모델링

# (1) knn
from sklearn.neighbors import KNeighborsClassifier
m_knn = KNeighborsClassifier()
m_knn.fit(train_x_sc, train_y)
m_knn.score(train_x_sc, train_y)
m_knn.score(test_x_sc, test_y)

m_knn.score(train_x_sc, train_y)
Out[151]: 0.9819166666666667

m_knn.score(test_x_sc, test_y)
Out[152]: 0.9688

# (2) pca + knn
from sklearn.neighbors import KNeighborsClassifier
from sklearn.decomposition import PCA
from sklearn.pipeline import make_pipeline

# 스케일링은 아까 수행했기 때문에 생략한다.
pipe = make_pipeline(PCA(100), KNeighborsClassifier(5))
pipe.fit(train_x_sc, train_y)
pipe.score(train_x_sc, train_y)
pipe.score(test_x_sc, test_y)

pipe.score(train_x_sc, train_y)
Out[159]: 0.9840333333333333

pipe.score(test_x_sc, test_y)
Out[160]: 0.9727

knn만 사용하는 것보다 pca + knn 을 같이 수행한 경우 score가 조금 더 향상되었다.

# 4) 예측 실패한 데이터 확인
pre_te = pipe.predict(test_x_sc)

pre_te
Out[162]: array([7, 2, 1, ..., 4, 5, 6], shape=(10000,), dtype=uint8)

pre_te != test_y

pre_te != test_y
Out[163]: array([False, False, False, ..., False, False, False], shape=(10000,))

test_fail = test_x[pre_te != test_y, :, :]

# 10,000개 중 273개를 예측 실패하였음을 확인할 수 있다.

test_x[pre_te != test_y, :, :]
Out[165]: 
array([[[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]],

       [[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]],

       [[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]],

       ...,

       [[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]],

       [[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]],

       [[0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        ...,
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0],
        [0, 0, 0, ..., 0, 0, 0]]], shape=(273, 28, 28), dtype=uint8)

y 역시 틀린 값만 추출해준다.

y_true_fail = test_y[pre_te != test_y]
y_pre_fail = pre_te[pre_te != test_y]

plt.imshow(test_fail[0])

y_true_fail[0]
y_pre_fail[0]

y_true_fail[0]
Out[171]: np.uint8(4)

y_pre_fail[0]
Out[172]: np.uint8(9)

실제값은 4, 예측값은 7로 예측실패하였음을 알 수 있다.

plt.imshow(test_fail[1])

y_true_fail[1]
y_pre_fail[1]

y_true_fail[1]
Out[174]: np.uint8(4)

y_pre_fail[1]
Out[175]: np.uint8(0)

# 여러 그래프를 동시에 시각화
fig, ax = plt.subplots(2,5)

# i는 y축 좌표
for i in range(0,10) :
    if i <= 4 :
        ax[0,i].imshow(test_fail[i])
        ax[0,i].set_title('true : %s, pre : %s' %(y_true_fail[i], y_pre_fail[i]))
    else :
        ax[1,i-5].imshow(test_fail[i])
        ax[1,i-5].set_title('true : %s, pre : %s' %(y_true_fail[i], y_pre_fail[i]))

03 ANN 모델을 사용한 이미지 분석

# 1. 데이터 로딩(RGB로 변환된 데이터)
from tensorflow.keras.datasets import mnist
import numpy as np

(train_x, train_y), (test_x, test_y) = mnist.load_data()

# 2. 데이터 변환
train_x_sc = train_x.reshape(60000, -1) / 255          # 0~255 -> 0~1 범위로 변환(minmax 스케일링 효과)
test_x_sc  = test_x.reshape(10000, -1) / 255           # 0~255 -> 0~1 범위로 변환(minmax 스케일링 효과)

# 원핫 인코딩
import pandas as pd
train_y10 = pd.get_dummies(train_y, prefix='Y').astype(int).values
test_y10  = pd.get_dummies(test_y, prefix='Y').astype(int).values

# 3. 모델링
# 1) seed 고정
import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Input(shape=(train_x_sc.shape[1], )))
model.add(Dense(392, activation='relu'))
model.add(Dense(196, activation='relu'))
model.add(Dense(98, activation='relu'))
model.add(Dense(10, activation='softmax'))

# 3) 오차함수, 최적화 결정
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights = True)

# 5) 학습
# * 각 에포크마다 반복 수 = 60000 * 0.75 / 10 = 4500
hist = model.fit(train_x_sc, train_y10, validation_split=0.25,
                 batch_size = 10, epochs=50000, callbacks=[es])

# 6) 평가
model.evaluate(train_x_sc, train_y10)[1]     # 0.9829
model.evaluate(test_x_sc, test_y10)[1]       # 0.9763

acc = hist.history['accuracy']
plt.plot(range(1, len(acc)+1), hist.history['accuracy'], label = 'train')
plt.plot(range(1, len(acc)+1), hist.history['val_accuracy'], label = 'val')
plt.legend()
plt.xticks(range(1, len(acc)+1))

# 4. 예측 실패한 데이터 시각화
pre_te = model.predict(test_x_sc).argmax(axis=1)

test_fail = test_x[ pre_te != test_y, :, :]
y_true_fail = test_y[ pre_te != test_y]
y_pre_fail = pre_te[ pre_te != test_y]

# 시각화
fig, ax = plt.subplots(5,5)
for i in range(0,25) :                  # i는 y축 좌표
    row = i // 5                        # 5로 나눈 몫
    col = i % 5                         # 5로 나눈 나머지
    ax[row, col].imshow(test_fail[i])
    ax[row, col].set_title('true : %s, pre : %s' % (y_true_fail[i], y_pre_fail[i]))
    ax[row, col].axis('off')

04 CNN 모델을 사용한 이미지 분석

컨볼루션 신경망 (CNN)은 입력된 이미지에서 다시 한 번 특징을 추출하기 위해 마스크 (필터, 윈도 또는 커널)을 도입하는 기법이다. (마스크가 가중치이다.)

즉, 하나의 레이어가 필터를 입혀서 기존 이미지를 요약하는 역할을 하게 된다.

마스크의 크기 및 개수는 개인이 설정하는 하이퍼파라미터로, 마스크의 크기 자체는 모델을 설계하는 사람이 선택한다.

마스크의 크기가 작아질수록 처리 시간이 오래 걸린다.

각 마스크가 공간의 패턴에 집중하며 돌아다니면서 가중치를 각 픽셀에 곱하고, 그러한 과정을 반복해서 새롭게 만들어진 층을 컨볼루션 (합성곱)이라고 부른다.

이미지 내에서도 불필요한 특징이 있을 수 있다.

이미지 데이터셋 자체가 원체 크기 때문에 불필요한 특징을 제하고 의미있는 신호만 남기는 것을 풀링이라고 한다.

이 때 풀링을 어떻게 지정하냐에 따라 달라지는데, 평균으로 요약해 도출하면 average pooling, 최소로 요약해 도출하면 min pooling, 최대로 요약해 도출하면 max pooling이라고 한다.

(일반적으로 신호가 강할수록 의미가 있기 때문에 max pooling을 사용한다.)

이 과정을 통해 불필요한 정보를 간추리게 된다.

1) 데이터 로딩(RGB로 변환된 데이터)
from tensorflow.keras.datasets import mnist
import numpy as np

(train_x, train_y), (test_x, test_y) = mnist.load_data()

# 데이터 확인
train_x.shape

train_x[0].shape
plt.imshow(train_x[0])

2) 변환

# 1) 설명변수 (스케일링, 차원 변경)

** Conv2D 층은 한 데이터의 입력을 (높이, 너비, 채널) 형태로 요구

(채널 : 흑백의 이미지인지 (1) 컬러의 이미지인지 (3)에 대한 차이)

** NN 모델은 스케일링에 매우 민감 -> 사전 스케일링이 필수적

train_x_sc = train_x / 255
test_x_sc = test_x / 255

train_x_sc = train_x_sc.reshape((60000, 28, 28, 1))
test_x_sc = test_x_sc.reshape((10000, 28, 28, 1))

# 2) 종속변수

train_y10 = pd.get_dummies(train_y).astype(int).values
test_y10 = pd.get_dummies(test_y).astype(int).values

# ** 참고 : 원핫 인코딩

# 1) pandas

pd.get_dummies(train_y).astype(int).values

# 2) keras

from tensorflow.keras.utils import to_categorical
to_categorical(train_y)

3) 모델링

# 1) seed 고정
import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D, Input

model = Sequential()
model.add(Input(shape=(28, 28, 1)))   # 한 데이터 기준 사이즈 전달
model.add(Conv2D(32, kernel_size = (2,2), activation='relu')) # 2*2 크기의 마스크를 32개 씌움
model.add(Conv2D(32, kernel_size = (2,2), activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

# 3) compile
model.compile('adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights = True)

# 5) 학습
# * 각 에포크마다 반복 수 = 60000 * 0.75 / 10 = 4500
hist = model.fit(train_x_sc, train_y10, validation_split=0.25,
                 batch_size = 10, epochs=50000, callbacks=[es])

# 6) 평가
model.evaluate(train_x_sc, train_y10)[1] # 0.9939
model.evaluate(test_x_sc, test_y10)[1] # 0.9869

model.evaluate(train_x_sc, train_y10)[1]     # 0.9829
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.9939 - loss: 0.0221        
Out[269]: 0.9938666820526123

model.evaluate(test_x_sc, test_y10)[1]       # 0.9763
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9869 - loss: 0.0499     
Out[270]: 0.9868999719619751

acc = hist.history['accuracy']
plt.plot(range(1, len(acc)+1), hist.history['accuracy'], label = 'train')
plt.plot(range(1, len(acc)+1), hist.history['val_accuracy'], label = 'val')
plt.legend()
plt.xticks(range(1, len(acc)+1))

4) 예측 실패한 데이터 시각화
pre_te = model.predict(test_x_sc).argmax(axis=1)

test_fail = test_x[ pre_te != test_y, :, :]
y_true_fail = test_y[ pre_te != test_y]
y_pre_fail = pre_te[ pre_te != test_y]

# 시각화
fig, ax = plt.subplots(5,5)
for i in range(0,25) :                  # i는 y축 좌표
    row = i // 5                        # 5로 나눈 몫
    col = i % 5                         # 5로 나눈 나머지
    ax[row, col].imshow(test_fail[i])
    ax[row, col].set_title('true : %s, pre : %s' % (y_true_fail[i], y_pre_fail[i]))
    ax[row, col].axis('off')

#2 2일차_인공신경망의 구조, 실습

ecosso — Fri, 24 Jul 2026 16:18:06 +0900

01 인공신경망의 구조

-01 layer + node

-02 활성함수

-03 오차함수

-04 최적화

-05 오차 역전파

-06 기울기 소실

02 실습

-01 ANN - 회귀

-02 ANN 튜닝 - batch_size, early stopping (적절한 epoch 결정)

-03 ANN - 분류

01 인공신경망의 구조

-01 layer + node

입력층 - 중간층 - 출력층 구조로 구성되어 있으며 각 층마다 여러 노드(뉴런)이 존재한다.

> 입력층 : 데이터를 전달받는 층 (노드의 수 = 피쳐 수)

> 출력층 : 최종 예측 결과를 리턴하는 층 (노드의 수 = 출력 결과)

* 회귀분석 : 1개의 target

* 분류분석 :

ex) 사망여부 -> 1개 target -> 원핫인코딩 (클래스별로 서로 다른 target 생성)* => Y_사망 Y_생존 (출력층 노드 수 2개)

ex) iris data 품종 -> 1개 target -> 원핫인코딩 => Y_1 Y_2 Y_3 (출력층 노드 수 3개)

> 중간층 : 하나의 층 구성에서부터 층을 추가하여 성능 비교 (층의 수, 노드 수 -> 사용자 결정*)

-02 활성함수 (사용자 결정*)

신호의 가중합을 다음 층에 전달할지의 여부를 결정한다.

sigmoid (0 : x < 0, 1 : x >=0), 렐루, 스텝 등

가중합의 크기가 0보다 작으면 0, 가중합의 크기가 0보다 크거나 같으면 1이다.

-03 오차함수

오차를 계산하여 오차를 줄이는 방향으로 기울기의 최적 구간을 탐색한다. (경사하강법)

* 회귀 분석 : MSE, RMSE, MAE 등

* 분류 분석 : cross entropy, binary cross entropy 등 (사용자 결정*)

-04 최적화 (사용자 결정*)

전체 데이터 수 = N

batch_size : 한 번 가중치 업데이트 시 사용하는 데이터의 수

iteration(step) : 1 epoch 동안 발생하는 업데이트 수 = N / batch_size

epochs : 전체 데이터를 1회 학습하는 단위

ex) N = 100

batch_size = 1

각 epoch마다 100건 중 단 1개의 데이터로 가중치 업데이트 100번 반복

batch_size = 100 (full batch = 배치 경사하강법)

각 epoch마다 100건 모두 사용하여 가중치 업데이트 1번 반복

batch_size = 10 (mini batch)

각 epoch마다 100/10 = 10개의 데이터로 가중치 업데이트 10번 반복

-05 오차 역전파

기울기와 오차와의 관계를 통해 기울기의 최적화를 진행한다.

중간층에서는 오차와 기울기의 관계를 파악할 수 없는 문제가 발생하며, 순전파를 통한 출력층의 오차를 이전층으로 분해하여 전달, 중간층에서도 기울기와 오차의 관계를 파악할 수 있다.

-06 기울기 소실

층이 늘어나면서 기울기가 0이 되는 현상이다.

시그모이드의 편미분값이 1보다 작아서 층마다 미분값이 곱해지는 과정에서 기울기가 0에 가까워진다.

하이퍼볼릭 탄젠트, 렐루, 소프트플러스 등으로 해결한다. (주로 렐루 사용)

02 실습

-01 ANN - 회귀

1) 데이터 로딩

import pandas as pd
boston = pd.read_csv('boston.csv')

boston.head()
Out[14]: 
      crim    zn  indus  chas    nox  ...  tax  ptratio   black  lstat  medv
0  0.00632  18.0   2.31     0  0.538  ...  296     15.3  396.90   4.98  24.0
1  0.02731   0.0   7.07     0  0.469  ...  242     17.8  396.90   9.14  21.6
2  0.02729   0.0   7.07     0  0.469  ...  242     17.8  392.83   4.03  34.7
3  0.03237   0.0   2.18     0  0.458  ...  222     18.7  394.63   2.94  33.4
4  0.06905   0.0   2.18     0  0.458  ...  222     18.7  396.90   5.33  36.2

[5 rows x 14 columns]

y = boston['medv']
X = boston.drop(columns='medv')

2) 스케일링

from sklearn.preprocessing import StandardScaler, MinMaxScaler
m_sc = StandardScaler()
X_sc = m_sc.fit_transform(X)

3) train / test 분리

from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X_sc, y, random_state=0)

4) 모델링

(1) seed 고정 (딥러닝은 외부에서 seed를 고정)

import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

(2) 모델 정의

from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Input(shape = (train_x.shape[1], ))) # 입력층은 Input 함수로 노드 구성 (노드수 = 설명변수 수)
model.add(Dense(6, activation = 'sigmoid'))
model.add(Dense(1)) # 회귀분석 출력층은 노드는 1개로 구성, 활성함수 None

* 중간층에만 activation function을 넣어준다.

(3) 오차함수, 최적화 결정

model.compile(optimizer='adam', loss='mse', metrics=['mae'])

(4) 학습

model.fit(train_x, train_y, epochs=500, batch_size = 10)

확률적 경사 하강법을 사용하며,

batch_size = 10 : 전체 데이터의 10%를 랜덤 선택하여 가중치 업데이트에 사용한다.

배치사이즈가 작아지면 속도는 빨라지나 안정성은 낮아진다. (편차가 커진다.)

epochs = 500 : 위 스텝을 500번 반복한다.

...
Epoch 498/500
38/38 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 10.2966 - mae: 2.3441
Epoch 499/500
38/38 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 10.2831 - mae: 2.3428
Epoch 500/500
38/38 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 10.2696 - mae: 2.3414

Out[42]: <keras.src.callbacks.history.History at 0x20fe69ac6e0>

379건의 10%를 사용하였기 때문에 Epoch 하단에 38이라는 숫자가 기재된다.

train_x.shape

train_x.shape
Out[43]: (379, 13)

(5) 평가

model.evaluate(test_x, test_y)[0] # loss (MSE)

model.evaluate(test_x, test_y)[0]
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - loss: 21.1461 - mae: 3.0215 
Out[45]: 21.14611053466797

model.evaluate(test_x, test_y)[1] # metrics (MAE)

model.evaluate(test_x, test_y)[1]
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - loss: 21.1461 - mae: 3.0215 
Out[46]: 3.0215461254119873

=> 500번 epoch train loss : 10.2696, test loss : 21.1461 (과적합 가능성 충분)

(6) 예측

model.predict(test_x)
test_y

test_y
Out[52]: 
329    22.6
371    50.0
219    23.0
403     8.3
78     21.2

49     19.4
498    21.2
309    20.3
124    18.8
306    33.4
Name: medv, Length: 127, dtype: float64

model.add(Dense(52, activation = 'relu'))
model.add(Dense(26, activation = 'relu'))
model.add(Dense(13, activation = 'relu'))

다음과 같이 다층으로 구성된 경우 sigmoid가 적절하지 않다. 이러한 경우일 때는 relu를 사용하는 것이 좋다.

-02 ANN 튜닝 - batch_size, early stopping (적절한 epoch 결정)

1) 데이터 로딩

import pandas as pd
boston = pd.read_csv('boston.csv')

boston.head()
Out[14]: 
      crim    zn  indus  chas    nox  ...  tax  ptratio   black  lstat  medv
0  0.00632  18.0   2.31     0  0.538  ...  296     15.3  396.90   4.98  24.0
1  0.02731   0.0   7.07     0  0.469  ...  242     17.8  396.90   9.14  21.6
2  0.02729   0.0   7.07     0  0.469  ...  242     17.8  392.83   4.03  34.7
3  0.03237   0.0   2.18     0  0.458  ...  222     18.7  394.63   2.94  33.4
4  0.06905   0.0   2.18     0  0.458  ...  222     18.7  396.90   5.33  36.2

[5 rows x 14 columns]

y = boston['medv']
X = boston.drop(columns='medv')

2) 스케일링

from sklearn.preprocessing import StandardScaler, MinMaxScaler
m_sc = StandardScaler()
X_sc = m_sc.fit_transform(X)

3) train / test 분리

from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X_sc, y, random_state=0)

4) 모델링

(1) seed 고정 (딥러닝은 외부에서 seed를 고정)

import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

(2) 모델 정의

* 중간층에만 activation function을 넣어준다.

(3) 오차함수, 최적화 결정

model.compile(optimizer='adam', loss='mse', metrics=['mae'])

(4) early stopping rule

충분한 epoch로 학습, 매 스텝마다 검증 오차를 체크하여 더 이상 개선이 없을 경우 학습을 중단한다.

ex= EarlyStopping(monitor='val_loss', # 모니터링 기준
patience=10, # 10회 동안 개선이 없을 경우 중단

restore_best_weights = True) # 최적 오차 도출

# 멈춘 시점이 아닌 검증오차가 최소였던 지점의 오차 기준으로 최종 모델을 선정

(5) 학습

hist = model.fit(train_x, train_y,

validation_split = 0.25, # train 데이터의 25%를 검증용 데이터로 선택

batch_size = 10, # 전체 데이터의 10%f를 랜덤 선택하여 가중치 업데이트에 사용

epochs = 50000, # 충분히 크게 설정

callbacks = [es]) # early stopping rule 추가

...
Epoch 126/50000
29/29 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 2.3838 - mae: 1.1503 - val_loss: 6.4815 - val_mae: 1.9125
Epoch 127/50000
29/29 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 2.3591 - mae: 1.1438 - val_loss: 6.3612 - val_mae: 1.9056
Epoch 128/50000
29/29 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 2.3255 - mae: 1.1320 - val_loss: 6.4057 - val_mae: 1.9069
Epoch 129/50000
29/29 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 2.3205 - mae: 1.1334 - val_loss: 6.3793 - val_mae: 1.9044
Epoch 130/50000
29/29 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 2.3036 - mae: 1.1307 - val_loss: 6.4116 - val_mae: 1.9115

(6) 평가

hist.history['loss'] # 매 epoch 마다의 학습오차
hist.history['val_loss'] # 매 epoch 마다의 검증오차

import matplotlib.pyplot as plt
plt.plot(hist.history['loss'], label = 'train')
plt.plot(hist.history['val_loss'], label = 'val')
plt.legend()

model.evaluate(train_x, train_y)

model.evaluate(train_x, train_y)
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 3.5405 - mae: 1.4057 
Out[90]: [3.540541172027588, 1.405723214149475]

model.evaluate(test_x, test_y)

model.evaluate(test_x, test_y)
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 7ms/step - loss: 16.4689 - mae: 2.9572 
Out[91]: [16.468944549560547, 2.957167625427246]

## ** 참고 : 위 그래프 출력 시 폰트 에러가 발생하는 경우 -> 기본 폰트 깨짐 현상 -> 폰트 캐시 재생성
import matplotlib
import shutil, os
cache_dir = matplotlib.get_cachedir()
print(ache_dir)
shutil.rmtree(cache_dir)

(7) batch size 튜닝

bs = [10, 20, 50, train_x.shape[0]]
for i in bs :
    seed = 0
    np.random.seed(seed)
    tf.random.set_seed(seed)

    # 모델 정의
    model = Sequential()
    model.add(Input(shape=(train_x.shape[1], )))
    model.add(Dense(6, activation='relu'))
    model.add(Dense(1))

    # 오차함수, 최적화 결정
    model.compile(optimizer='adam', loss='mse', metrics=['mae','r2_score'])

    # early stopping rule
    es = EarlyStopping(monitor='val_loss',
                       patience=10,
                       restore_best_weights = True)

    # 학습
    hist = model.fit(train_x, train_y,
                     validation_split=0.25, verbose= 0,
                     batch_size = i,
                     epochs=50000,
                     callbacks=[es])

    # 최적 반복수 확인
    be = np.argmin(hist.history['val_loss']) + 1
    print(f'batch_size : {i}, 최적 반복수 : {be}')

    # 평가
    print(model.evaluate(train_x, train_y)[0])
    print(model.evaluate(test_x, test_y)[0])

batch_size : 10, 최적 반복수 : 1673
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 8.2063 - mae: 2.0459 - r2_score: 0.9038 
8.206317901611328
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 6ms/step - loss: 21.7978 - mae: 3.0250 - r2_score: 0.7332 
21.797828674316406
batch_size : 20, 최적 반복수 : 974
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 8.5905 - mae: 2.1381 - r2_score: 0.8993 
8.590462684631348
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 6ms/step - loss: 20.6176 - mae: 3.0851 - r2_score: 0.7476 
20.617616653442383
batch_size : 50, 최적 반복수 : 2302
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 8.3724 - mae: 2.1259 - r2_score: 0.9019 
8.372426986694336
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - loss: 20.5260 - mae: 3.0028 - r2_score: 0.7488 
20.525999069213867
batch_size : 379, 최적 반복수 : 5407
12/12 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - loss: 13.3568 - mae: 2.6968 - r2_score: 0.8434
13.356831550598145
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - loss: 25.5050 - mae: 3.6179 - r2_score: 0.6878 
25.504959106445312

-03 ANN - 분류

회귀분석과는 다르게 출력층에서 반드시 가중합을 학습된 Y의 형태 (0 or 1)로 변환하는 장치 필요 --> 활성함수 (sigmoid)

출력층의 유닛(노드)의 수가 1개가 아닐 수 있음*

(1) 데이터 로딩
cancer = pd.read_csv('cancer.csv')
y = cancer['diagnosis']
X = cancer.drop(columns=['id','diagnosis'])

(2) 라벨링
y = (y == 'Malignant').astype('int')                # 출력층 노드 수 1개로 설정 필요
y2 = pd.get_dummies(y, prefix='Y').astype('int')    # 출력층 노드 수 2개로 설정 필요

(3) 스케일링
from sklearn.preprocessing import MinMaxScaler
m_sc = MinMaxScaler()
X_sc = m_sc.fit_transform(X)

(4)train / test 분리
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(X_sc, y2, random_state=0)

(5) 모델링
# 1) seed 고정
import numpy as np
import tensorflow as tf
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)

# 2) 모델 정의
from tensorflow.keras.layers import Input
from keras import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Input(shape=(train_x.shape[1], )))
model.add(Dense(15, activation='relu'))
model.add(Dense(2, activation='sigmoid'))

# 3) 오차함수, 최적화 결정
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 4) early stopping rule
from tensorflow.keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_loss',
                   patience=10,
                   restore_best_weights = True)

# 5) 학습
hist = model.fit(train_x, train_y,
                 validation_split=0.25,
                 batch_size = 10,
                 epochs=50000,
                 callbacks=[es])

# 6) 평가
hist.history['loss']                      # 매 epoch 마다의 학습오차
hist.history['val_loss']                  # 매 epoch 마다의 검증오차
hist.history['accuracy']                  # 매 epoch 마다의 학습 정확도
hist.history['val_accuracy']              # 매 epoch 마다의 검증 정확도

import matplotlib.pyplot as plt
fig, ax = plt.subplots(1,2)
ax[0].plot(hist.history['loss'], label = 'train')
ax[0].plot(hist.history['val_loss'], label = 'val')
ax[0].legend()

ax[1].plot(hist.history['accuracy'], label = 'train')
ax[1].plot(hist.history['val_accuracy'], label = 'val')
ax[1].legend()

model.evaluate(train_x, train_y)          # accuracy: 0.9883 - loss: 0.0310
model.evaluate(test_x, test_y)            # accuracy: 0.9441 - loss: 0.2931

#1 1일차_tensorflow, keras 설치하기

ecosso — Thu, 23 Jul 2026 16:21:06 +0900

01 설치하기

pip install tensorflow

* 만약 ImportError : DLL load failed while importing _pywrap_profiler 이라는 오류가 발생한 경우, 애플리케이션 제어 정책에서 파일을 차단하는 경우이다.

윈도우 검색 > 스마트 앱 컨트롤 > 끄기로 설정이 가능하다.

tensor라는 언어를 베이스로 개발된 keras라는 언어도 있다.

이 역시 설치를 진행한다.

pip install keras

spyder 등에서 import tensorflow as tf, import keras 등을 통해 설치가 제대로 진행되었는지 확인할 수 있다.

#7 7일차_반복 제어문, sed, awk

ecosso — Thu, 23 Jul 2026 12:54:38 +0900

01 반복 제어문

02 sed - 비대화형 편집기

03 awk - 자료처리

-01 산술연산

-02 grep

-03 cut

01 반복 제어문

- continue

특정 조건을 만나면 반복문 스킵, 다음 대상부터 다시 반복문을 수행한다.

ex)

for fname in $(ls *.sh)

if [ $fname = "a.sh" ]

then

exit 1

echo "$fname"

done

echo "프로그램 종료"

exit 0

vi 22_continue.sh

#!/bin/sh

for i in $(seq 1 10)
do
  echo "숫자 출력"
  if [ $i -eq 5 ]
  then
    continue
  fi
  echo "현재번호 : $i"
done

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sh 22_continue.sh
숫자 출력
현재번호 : 1
숫자 출력
현재번호 : 2
숫자 출력
현재번호 : 3
숫자 출력
현재번호 : 4
숫자 출력
숫자 출력
현재번호 : 6
숫자 출력
현재번호 : 7
숫자 출력
현재번호 : 8
숫자 출력
현재번호 : 9
숫자 출력
현재번호 : 10

break 실습으로 변경해보았다.

#!/bin/sh

for i in $(seq 1 10)
do
  echo "숫자 출력"
  if [ $i -eq 5 ]
  then
    break
  fi
  echo "현재번호 : $i"
done
echo "프로그램 종료"

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sh 22_continue.sh
숫자 출력
현재번호 : 1
숫자 출력
현재번호 : 2
숫자 출력
현재번호 : 3
숫자 출력
현재번호 : 4
숫자 출력
프로그램 종료

vi 23_menu.sh

#!/bin/sh

# env
dir=/home/itwill/linux_ex/ch8
todate=`date +%Y%m%d`

# function def
f_menu() {
  echo "메뉴를 입력하세요(p:prior, q:quit) ☞ \c"
  read ans2
  case $ans2 in 
    p|P)
      echo "이전 메뉴로 돌아가겠습니다\c"
      for i in . . .
      do
        echo "$i\c"
        sleep 1
      done
      contitue
      ;;
    q|Q)
      echo "프로그램을 종료하겠습니다\c"
      for i in . . .
      do
        echo "$i\c"
        sleep 1
      done
      break
      ;;
    *)
      echo "잘못 입력되었습니다. 프로그램을 종료합니다."
      exit 1
      ;;
  esac
}

f_wait() {
  for i in . . .
  do
    echo "$i\c"
    sleep 1
  done
  echo
}

# main shell
clear

while [ 1 ]
do
  clear
  echo "┌─────────────────────────┐"
  echo "│       관리자 화면       │"
  echo "└─────────────────────────┘"
  echo "┌─────────────────────────┐"
  echo "│  1. 유저 확인           │"
  echo "│  2. 파일 확인           │"
  echo "└─────────────────────────┘"
  echo
  echo "메뉴를 입력하세요(q:quit) ☞ \c"
  read ans

  case $ans in
    1)
      echo "유저 확인 화면으로 전환됩니다\c"
      f_wait              # 대기 프롬프트 출력

      clear
      echo "┌─────────────────────────┐"
      echo "│        유저 확인        │"
      echo "└─────────────────────────┘"
      echo 

      echo "유저명을 입력하세요 ☞ \c"
      read username

      if grep -w ^$username /etc/passwd > /dev/null
      then
        hdir=`grep -w ^$username /etc/passwd | cut -d: -f6`
        shell=`grep -w ^$username /etc/passwd | cut -d: -f7`
        echo
        echo "〓〓〓〓〓〓 결과 〓〓〓〓〓〓"
        echo
        echo "사용자명   : $username"
        echo "홈디렉토리 : $hdir"
        echo "로긴쉘     : $shell"
        echo
        echo "〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓"
        echo
        f_menu                # 이전으로 돌아가기, 프로그램 종료 메뉴 출력
      else
        echo "$username 유저가 존재하지 않습니다."
        exit 1
      fi
      ;;
    2) 
      echo "파일 확인 화면으로 전환됩니다\c"
      f_wait              # 대기 프롬프트 출력

      clear
      echo "┌─────────────────────────┐"
      echo "│        파일 확인        │"
      echo "└─────────────────────────┘"
      echo 

      echo "파일명을 입력하세요 ☞ \c "
      read fname
      
      if [ -f $fname ]
      then
        fsize=`ls -l $fname | cut -d" " -f5`
        fown=`ls -l $fname | cut -d" " -f3`
        echo
        echo "〓〓〓〓〓〓 결과 〓〓〓〓〓〓"
        echo
        echo "파일명 : $fname"
        echo "소유자 : $fown"
        echo "크기   : $fsize"
        echo
        echo "〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓"
        echo
        f_menu
      else
        echo "$fname 파일이 존재하지 않습니다."
      fi
      ;;
    q|Q)
      echo "프로그램을 종료하겠습니다\c"
      f_wait
      break
      ;;
    *)
      echo "잘못된 입력입니다."
      echo "프로그램을 종료하겠습니다\c"
      f_wait
      exit 1
      ;;
  esac
done

echo "프로그램 정상 종료"

┌─────────────────────────┐
│       관리자 화면       │
└─────────────────────────┘
┌─────────────────────────┐
│  1. 유저 확인           │
│  2. 파일 확인           │
└─────────────────────────┘

메뉴를 입력하세요(q:quit) ☞ 2

┌─────────────────────────┐
│        파일 확인        │
└─────────────────────────┘

파일명을 입력하세요 ☞ /home/itwill/linux_ex/ch9/23_menu.sh

〓〓〓〓〓〓 결과 〓〓〓〓〓〓

파일명 : /home/itwill/linux_ex/ch9/23_menu.sh
소유자 : itwill
크기   : 3696

〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓

메뉴를 입력하세요(p:prior, q:quit) ☞

02 sed - 비대화형 편집기

동시에 여러 파일을 vi 편집기 없이 수정이 가능한 기능이다.

명령어로 파일 편집이 가능하다 (글자입력, 행 삭제, 글자 치환 등)

* 사용법

sed [옵션] '명령어' 파일명

* 명령어

읽기(r)

출력(p)

삭제(d)

입력(i,a)

치환(s)

* 옵션

-n : 원하는 라인만 출력

-e : 다중편집

ex)

set '5d' test.txt -> 5번행 삭제

sed '1,5d' test.txt -> 1~5행 삭제

sed '/root'd' test.txt -> root가 포함된 행 삭제

sed 'root/!d' test.txt -> root가 포함되지 않은 행 삭제

sed '/^#/d' test.txt -> 주석처리된 행 삭제

sed /^$/d' test.txt -> 빈줄 삭제

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cat -n /etc/passwd | head -10
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     5  sync:x:4:65534:sync:/bin:/bin/sync
     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cat -n /etc/passwd | head -10 > test.txt

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '5d' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin


itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '1,5d' test.txt
     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '/root/d' test.txt
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     5  sync:x:4:65534:sync:/bin:/bin/sync
     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin

주석처리된 라인도 삭제할 수 있다.

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cat test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '/^#/d' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin

ex)

sed '5p' test.txt -> 5번 행이 한 번 더 출력

sed -n '5p' 'test.txt -> 5번행만 출력

sed -n '/root/p/ test.txt -> root 단어가 포함된 라인만 출력

sed -n '/^$/p' test.txt | wc -l -> 빈 줄의 수 출력

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ set '5p' test.txt
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed -n '5p' test.txt
#     5 sync:x:4:65534:sync:/bin:/bin/sync

ex)

sed 's/nologin//' test.txt -> 전체 범위에서 nologin 단어 삭제
sed '2s/nologin//' test.txt -> 2번 행의 nologin 단어 삭제

sed '2,5s/nologin//' test.txt -> 2~5번 행의 nologin 단어 삭제
sed '2,5!s/nologin//' test.txt -> 2~5번 행을 제외한 나머지 행에서 nologin 단어 삭제
sed '3s/bin/BIN/' test.txt -> 2~5번 행을 제외한 나머지 행에서 nologin 단어 삭제
sed '3s/bin/BIN/' test.txt -> 3번행에서 bin을 BIN으로 치환(첫번째 단어만 치환됨)
sed '3s/bin/BIN/g' test.txt -> 3번행에서 bin을 BIN으로 치환(모든 단어가 치환됨)

sed '1,2s/%/#3/' text.txt -> 1~2번행 주척처리

sed '5,6s/^#//' test.txt -> 5~6번행 주석해지

sed '1,3s/^/ /' test.txt -> 1~3번행 두 칸 들여쓰기

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cat test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed 's/nologin//' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/
     3  bin:x:2:2:bin:/bin:/usr/sbin/
     4  sys:x:3:3:sys:/dev:/usr/sbin/
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '2s/nologin//' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '2,5!s/nologin//' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '3s/bin/BIN/' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  BIN:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '3s/bin/BIN/g' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  BIN:x:2:2:BIN:/BIN:/usr/sBIN/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
    itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '5,6s/^#//' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     5  sync:x:4:65534:sync:/bin:/bin/sync
     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '8,9s/^/  /' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
       8        lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
       9        mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin

ex)

i,a)

sed '5i\==========' test.txt -> 5번 라인에 '=========='를 입력

sed '5a\==========' test.txt -> 5번 라인 밑에 '=========='를 입력

sed '3r file.txt' test.txt -> test.txt 파일 3번행 다음 행에 file.txt 내용을 불러오기

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ echo "abcde......" -> file.txt
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ echo "abcde......" >> file.txt
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cat file.txt
abcde...... -
abcde......

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '3r file.txt' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
abcde...... -
abcde......
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
#     5 sync:x:4:65534:sync:/bin:/bin/sync
#     6 games:x:5:60:games:/usr/games:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin

ex)

sed -e '/^#/d' -e 's/bin//' test.txt ->
sed -e '/^#/d' -e 's'bin''g' test.txt ->

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed '/^#/d' test.txt
     1  root:x:0:0:root:/root:/bin/bash
     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
     3  bin:x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/sbin/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
    
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ sed -e '/^#/d' -e 's/bin//' test.txt
     1  root:x:0:0:root:/root://bash
     2  daemon:x:1:1:daemon:/usr/s:/usr/sbin/nologin
     3  :x:2:2:bin:/bin:/usr/sbin/nologin
     4  sys:x:3:3:sys:/dev:/usr/s/nologin
     7  man:x:6:12:man:/var/cache/man:/usr/s/nologin
     8  lp:x:7:7:lp:/var/spool/lpd:/usr/s/nologin
     9  mail:x:8:8:mail:/var/mail:/usr/s/nologin
    10  news:x:9:9:news:/var/spool/news:/usr/s/nologin

# 실습하기

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ mkdir data
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ cd data
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ cp /etc/services services1
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ cp /etc/services services2
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ cp /etc/services services3
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ cp /etc/services services4
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ cp /etc/services services5

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ head -10 services1
# Network services, Internet style
#
# Updated from https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml .
#
# New ports will be added on request if they have been officially assigned
# by IANA and used in the real-world or are needed by a debian package.
# If you need a huge list of used numbers please install the nmap package.

tcpmux          1/tcp                           # TCP port service multiplexer
echo            7/tcp

vi 24_sed.sh

#!/binsh

# data 디렉토리 하위 모든 파일을 1~7행 삭제 후 저장

maindir=/home/itwill/linux_ex/ch9/data

flist=$(find $maindir -maxdepth 1 -type f)

for fname in $flist
do
  echo "$fname 파일을 수정하겠습니다."
  sed '1,7d $fname > $fname_imsi
  mv ${fname}_imsi $fname
done

03 awk - 자료처리

* 사용법

awk [옵션] '[/검색] {명령어}' 파일

-01 산술연산

$ echo | awk '{print 1+2}'

-02 grep

awk /itwill/ /etc/passwd

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ echo | awk '{print 1 + 2}'
3
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ awk /itwill/ /etc/passwd
itwill:x:1000:1000:itwill:/home/itwill:/bin/bash
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ grep itwill /etc/passwd
itwill:x:1000:1000:itwill:/home/itwill:/bin/bash
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ echo abced | cut -c1,3
ac
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9$ echo abcde | cut -c1-3
abc

-03 cut

echo "1:2:3" | awk -F: '{print $1}' -> :으로 필드를 구분하여 첫 번째 필드 출력

echo "1:2:3" | awk -F: '{print $NF}' -> 마지막 필드 출력

echo "1:2:3" | awk -F: '{print $(NF-1)}' -> 마지막 이전 필드 출력

echo "1:2:3" | awk -F: '{print $1"..."$2}' -> print로 위치변수와 일반문자열을 함께 출력할 수 있음 (""로 일반 문자열을 묶어 전달)

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ echo "1:2:3" | awk -F: '{print $1}'
1

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ echo "1:2:3" | awk -F: '{print $NF}'
3

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ echo "1:2:3" | awk -F: '{print $(NF-1)}'
2

** 참고 : 외부 변수 값 전달

username=itwill

awk -F: '/$username/ {print $NF}' /etc/passwd -> 아무것도 출력되지 않는다. (홑따옴표 안의 $는 변수호출로 해석이 불가능)

awk -F: '/'$username'/ {print $NF}' /etc/passwd -> 정상출력

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ awk -F: '/itwill/ {print $NF}' /etc/passwd
/bin/bash

itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ username=itwill
itwill@itwill-VMware-Virtual-Platform:~/linux_ex/ch9/data$ awk -F: '/$username/ {print $NF}' /etc/passwd

#6 6일차_파이썬 스크립트 실행, 로깅 처리, 정렬, 특수기호 정의

ecosso — Wed, 22 Jul 2026 16:13:35 +0900

01 리눅스에서 파이썬 스크립트 실행하기

02 로깅 처리

-01 echo

-02 tee

03 정렬

-01 ls 결과 정렬

-02 sort

04 특수기호 정의

-01 * 과 ?

-02 []

-03 ~와 -

-04 ''와 ""

-05 ; 과 |

05 논리 연산자

-01 and 연산자

-02 or 연산자

-03 not 연산자

01 리눅스에서 파이썬 스크립트 실행하기

os 프롬포트에서 파이썬 프롬프트로 명령어 전달을 수행할 수 있다. (입력 프롬프트를 사용)

ipython 사용 시 쓸데없는 헤더들을 출력하고 싶지 않다면 --no-banner와 함께 python prompt로 진입하는 것도 좋다.

(base) itwill@ubuntu:~$ cds
(base) itwill@ubuntu:~/linux_ex/ch9$ ipython
Python 3.12.7 | packaged by Anaconda, Inc. | (main, Oct  4 2024, 13:27:36) [GCC 11.2.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 8.27.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: exit

(base) itwill@ubuntu:~/linux_ex/ch9$ ipython --no-banner

In [1]:

vi 19_ipython.sh

#!/bin/sh

echo "파이썬 스크립트를 시작하겠습니다..."
sleep 2

maindir=/home/itwill/linux_ex/ch9

ipython --no-banner --no-confirm-exit << _eof_
import pandas as pd
emp = pd.read_csv("$maindir/emp.csv")
mean_sal = round(emp.loc[emp['DEPTNO'] == 10, 'SAL'].mean())
print(mean_sal)
_eof_

echo "파이썬 스크립트를 종료하겠습니다..."

쉘스크립트와 파이썬이 섞여있다. 따라서 end of file이라는 뜻의 _eof_로 파이썬 스크립트의 시작과 끝을 지정한다.

(_eof_의 경우 원하는 형태로 작성 가능하다.)

$ ipython --no -banner -- no-confirm-exit << _eof

python 명령어...

_eof_

** 참고 : 리눅스에서 한글 깨짐 해결 (인코딩 변경)

$ iconv -f CP949 -t UTF8 card_history.csv > card_history_new.csv

** 참고 : os 프롬포트에서 sql 프롬포트로 명령어 전달하기

$ sqlplus -s scott/oracle << _eof_

select ...;

_eof_

$ R << _eof_

R 명령어...

_eof_

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 19_ipython.sh
파이썬 스크립트를 시작하겠습니다...

In [1]:
In [2]:
In [3]:
In [4]: 2917

In [5]: 파이썬 스크립트를 종료하겠습니다...

vi 19_ipython.sh를 card 관련 코드로 변경해본다.

#!/bin/sh

echo "파이썬 스크립트를 시작하겠습니다..."
sleep 2

maindir=/home/itwill/linux_ex/ch9

ipython --no-banner --no-confirm-exit << _eof_  > /dev/null
import pandas as pd
card = pd.read_csv('$maindir/card_history.csv')
card = card.drop(columns='NUM')
card = card.map(lambda x : int(x.replace(',','')))
card.sum().to_csv("$maindir/total.csv", header=False)
_eof_

echo
echo "파이썬 스크립트를 종료하겠습니다..."

if [ -f $maindir/total.csv ]
then
  echo "분석 스크립트 정상 수행 완료"
  cat $maindir/total.csv
else
  echo "스크립트 실행 오류 발생"
fi

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 19_ipython.sh
파이썬 스크립트를 시작하겠습니다...

파이썬 스크립트를 종료하겠습니다...
분석 스크립트 정상 수행 완료
식료품,795500
의복,3947700
외식비,281400
책값,945000
온라인소액결제,186300
의료비,633600

[ 연습문제 - 20_ipython2.sh ]

** 참고 : 리눅스에서 한글 깨짐 해결 (인코딩 변경)

$ iconv -f CP949 -t UTF8 delivery.csv > delivery_new.csv

$ delivery_new.csv delivery.csv

delivery.csv 파일을 읽고 시간대별배달건수가 가장 많은 업종의 이름을 출력 후 result.csv로 저장.

저장 후 결과 출력하기.

[ 내 답변 ]

#!/bin/sh

echo "파이썬 스크립트를 시작하겠습니다..."
sleep 2

maindir=/home/itwill/linux_ex/ch9

ipython --no-banner --no-confirm-exit << _eof_ > /dev/null
import pandas as pd
delivery = pd.read_csv('$maindir/delivery_new.csv')
delivery = delivery.drop(columns=['시도','시군구','읍면동'])
df = delivery.groupby(["시간대","업종"])["통화건수"].sum()
result = df.groupby(level=0).idxmax()
result = result.apply(lambda x: x[1])
result.name = "업종"
result.index.name = "시간대"
result.to_csv("$maindir/result.csv", header=False)
_eof_

echo
echo "파이썬 스크립트를 종료하겠습니다..."

if [ -f $maindir/result.csv ]
then
  echo "분석 스크립트 정상 수행 완료"
  cat $maindir/result.csv
else
  echo "스크립트 실행 오류 발생"
fi

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 20_ipython2.sh
파이썬 스크립트를 시작하겠습니다...

파이썬 스크립트를 종료하겠습니다...
분석 스크립트 정상 수행 완료
0,치킨
1,치킨
2,음식점-중국음식
3,음식점-중국음식
4,음식점-중국음식
5,음식점-중국음식
6,음식점-중국음식
7,음식점-중국음식
8,음식점-중국음식
9,음식점-중국음식
10,음식점-중국음식
11,음식점-중국음식
12,음식점-중국음식
13,음식점-중국음식
14,음식점-중국음식
15,음식점-중국음식
16,음식점-중국음식
17,치킨
18,치킨
19,치킨
20,치킨
21,치킨
22,치킨
23,치킨

[ 문제풀이 ] + 여러가지 옵션 
#!/bin/sh

# env
maindir=/home/itwill/linux_ex/ch9
logdir=$maindir/log

if [ ! -d $logdir ]
then
  mkdir -p $logdir
fi

# main
echo "파이썬 분석 프로그램 실행\c"
for i in . . .
do
  echo "${i}\c"
  sleep 1
done
echo

# 파이썬 프롬프트 실행
start_time=$(date +%s)                           # 시작시간 체크
echo "시작 시간 : $(date '+%Y/%m/%d %H:%M:%S')"

ipython --no-banner --no-confirm-exit << _eof_ > /dev/null
import pandas as pd
df = pd.read_csv("$maindir/delivery.csv")
df_new = df.groupby(['시간대','업종'])['통화건수'].sum().reset_index()
df_new['최대통화건수'] = df_new.groupby('시간대')['통화건수'].transform('max')
result = df_new.query('최대통화건수 == 통화건수')[['시간대','업종']]
result.to_csv("$maindir/result.csv", index=False)
_eof_

end_time=$(date +%s)                              # 종료시간 체크
elapsed=$(expr $end_time - $start_time)           # 경과시간 계산

echo "파이썬 분석 프로그램 종료"
echo "종료 시간 : $(date '+%Y/%m/%d %H:%M:%S')"
echo "소요 시간: ${elapsed}초"
echo "출력건수 : $(cat $maindir/result.csv | wc -l) 건"

# 분석 결과 체크
if [ -f $maindir/result.csv ]
then
  echo "분석 스크립트 정상 수행 완료"
  echo "┌────────────────────────────┐"
  echo "│       분석 결과 출력        │"
  echo "└────────────────────────────┘"
  cat $maindir/result.csv
else
  echo "스크립트 실행 오류 발생"
fi

# 분석 결과 삭제
rm $maindir/result.csv

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 20_ipython2.sh
파이썬 분석 프로그램 실행...
시작 시간 : 2026/07/22 11:50:17
파이썬 분석 프로그램 종료
종료 시간 : 2026/07/22 11:50:18
소요 시간: 1초
출력건수 : 24 건
분석 스크립트 정상 수행 완료
┌────────────────────────────┐
│       분석 결과 출력        │
└────────────────────────────┘
0,치킨
1,치킨
2,음식점-중국음식
3,음식점-중국음식
4,음식점-중국음식
5,음식점-중국음식
6,음식점-중국음식
7,음식점-중국음식
8,음식점-중국음식
9,음식점-중국음식
10,음식점-중국음식
11,음식점-중국음식
12,음식점-중국음식
13,음식점-중국음식
14,음식점-중국음식
15,음식점-중국음식
16,음식점-중국음식
17,치킨
18,치킨
19,치킨
20,치킨
21,치킨
22,치킨
23,치킨

02 로깅 처리

-01 echo

if [ ! -f ...]

then

echo "파일이 존재하지 않습니다." >> test.log

echo "프로그램 시작시간" >> test.log

-02 tee

표준출력(모니터)과 특정 파일에 동시 출력이 가능하다.

즉, tee는 백그라운드에서 실행도 되지만 화면에 동시에 실행결과도 출력해준다.

* 사용법

echo "문자열" | tee [옵션]

* 옵션

-a : 이어쓰기

(base) itwill@ubuntu:~/linux_ex/ch9$ echo "프로그램 시작" >> test.log
(base) itwill@ubuntu:~/linux_ex/ch9$ cat test.log
프로그램 시작

(base) itwill@ubuntu:~/linux_ex/ch9$ echo "프로그램 종료" | tee -a test.log
프로그램 종료

(base) itwill@ubuntu:~/linux_ex/ch9$ cat test.log
프로그램 시작
프로그램 종료

vi 20_ipython2.sh

#!/bin/sh

# env
maindir=/home/itwill/linux_ex/ch9
logdir=$maindir/log
todate=$(date +%Y%m%d)

if [ ! -d $logdir ]
then
  mkdir -p $logdir
fi

# main
echo "파이썬 분석 프로그램 실행" | tee -a ${logdir}/python_${todate}.log
#for i in . . .
#do
#  echo "${i}\c"
#  sleep 1
#done
#echo

# 파이썬 프롬프트 실행
start_time=$(date +%s)                           # 시작시간 체크
echo "시작 시간 : $(date '+%Y/%m/%d %H:%M:%S')" | tee -a ${logdir}/python_${todate}.log

ipython --no-banner --no-confirm-exit << _eof_ > /dev/null
import pandas as pd
df = pd.read_csv("$maindir/delivery.csv")
df_new = df.groupby(['시간대','업종'])['통화건수'].sum().reset_index()
df_new['최대통화건수'] = df_new.groupby('시간대')['통화건수'].transform('max')
result = df_new.query('최대통화건수 == 통화건수')[['시간대','업종']]
result.to_csv("$maindir/result.csv", index=False)
_eof_

end_time=$(date +%s)                              # 종료시간 체크
elapsed=$(expr $end_time - $start_time)           # 경과시간 계산

echo "파이썬 분석 프로그램 종료" | tee -a ${logdir}/python_${todate}.log
echo "종료 시간 : $(date '+%Y/%m/%d %H:%M:%S')" | tee -a ${logdir}/python_${todate}.log
echo "소요 시간: ${elapsed}초" | tee -a ${logdir}/python_${todate}.log
echo "출력건수 : $(cat $maindir/result.csv | wc -l) 건" | tee -a ${logdir}/python_${todate}.log

# 분석 결과 체크
if [ -f $maindir/result.csv ]
then
  echo "분석 스크립트 정상 수행 완료" | tee -a ${logdir}/python_${todate}.log
  echo "┌────────────────────────────┐" | tee -a ${logdir}/python_${todate}.log
  echo "│       분석 결과 출력        │" | tee -a ${logdir}/python_${todate}.log
  echo "└────────────────────────────┘" | tee -a ${logdir}/python_${todate}.log
  cat $maindir/result.csv | tee -a ${logdir}/python_${todate}.log
else
  echo "스크립트 실행 오류 발생" | tee -a ${logdir}/python_${todate}.log
fi

# 분석 결과 삭제
rm $maindir/result.csv

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 20_ipython2.sh
파이썬 분석 프로그램 실행
시작 시간 : 2026/07/22 13:01:23
파이썬 분석 프로그램 종료
종료 시간 : 2026/07/22 13:01:24
소요 시간: 1초
cat: /home/itwill/linux_ex/ch9/result.csv: No such file or directory
출력건수 : 0 건
스크립트 실행 오류 발생
rm: cannot remove '/home/itwill/linux_ex/ch9/result.csv': No such file or directory

03 정렬

-01 ls 결과 정렬

* 정렬 옵션

-v : 자연정렬 (파일/디렉토리명에 숫자가 포함된 경우 숫자 기준으로 정렬)

-t : 시간정렬 (최근 수정 파일이 상단에 출력됨)

-r : 역순정렬

(base) itwill@ubuntu:~/linux_ex/ch9$ ls -lv
total 14016
-rwxr--r-- 1 itwill itwill     377 Jul 16 11:34 1_grep.sh
-rwxr--r-- 1 itwill itwill     242 Jul 16 12:00 2_cut.sh
-rwxr--r-- 1 itwill itwill     480 Jul 16 14:54 3_wc.sh
-rw-rw-r-- 1 itwill itwill     303 Jul 16 15:58 4_if1.sh
-rw-rw-r-- 1 itwill itwill     721 Jul 20 10:44 5_backup.sh
-rw-rw-r-- 1 itwill itwill     767 Jul 20 11:26 6_case.sh
-rw-rw-r-- 1 itwill itwill     389 Jul 20 12:15 7_head.sh
-rwxrwxr-x 1 itwill itwill      79 Jul 20 14:40 8_cron.sh
-rw-rw-r-- 1 itwill itwill     390 Jul 20 19:07 9_for1.sh
-rw-rw-r-- 1 itwill itwill     725 Jul 20 19:35 10_for2.sh
-rw-rw-r-- 1 itwill itwill     354 Jul 20 20:00 11_expr.sh
-rw-rw-r-- 1 itwill itwill     251 Jul 20 20:03 12_bc.sh
-rw-rw-r-- 1 itwill itwill     320 Jul 20 20:39 13_color.sh
-rw-rw-r-- 1 itwill itwill     597 Jul 21 12:50 14_text_color.sh
-rw-rw-r-- 1 itwill itwill     119 Jul 21 12:58 15_export1.sh
-rw-rw-r-- 1 itwill itwill      80 Jul 21 12:57 16_export2.sh
-rw-rw-r-- 1 itwill itwill     154 Jul 21 15:08 17_python.py
-rw-rw-r-- 1 itwill itwill     232 Jul 21 15:35 18_python.py
-rw-rw-r-- 1 itwill itwill     610 Jul 22 10:20 19_ipython.sh
-rw-rw-r-- 1 itwill itwill    2147 Jul 22 13:01 20_ipython2.sh
drwxrwxr-x 2 itwill itwill    4096 Jul 20 10:28 backup
-rw-rw-r-- 1 itwill itwill    1721 Mar 30 10:07 card_history.csv
-rw-rw-r-- 1 itwill itwill     320 Jul 21 12:04 color.env
-rw-rw-r-- 1 itwill itwill   38493 Jul 22 13:04 cron.log
-rw-rw-r-- 1 itwill itwill 6027546 Mar 30 10:07 delivery.csv
-rw-rw-r-- 1 itwill itwill 7914024 Jul 22 11:10 delivery_new.csv
-rw-rw-r-- 1 itwill itwill     734 Mar 30 10:07 emp.csv
-rw-rw-r-- 1 itwill itwill  239690 Jul 21 14:16 index.html
drwxr--r-- 2 itwill itwill    4096 Jul 22 12:59 log
-rwxr--r-- 1 itwill itwill     161 Jul 16 12:14 sh_260716.log
-rw-rw-r-- 1 itwill itwill      40 Jul 22 12:16 test.log
-rwxr--r-- 1 itwill itwill       8 Jul 16 11:06 test.txt
-rw-rw-r-- 1 itwill itwill     109 Jul 21 15:36 total.csv

-02 sort

파일 안의 내용을 정렬한다.

* 사용법

sort [옵션] 파일명

cat 파일명 | sort [옵션]

* 옵션

-n : 숫자 정렬

-r : 역순 정렬

-k : 필드 위치 지정 (ex. -k2 -> 두번째 필드값 기준으로 정렬)

-t : 필드 구분자 지정, 생략시 탭 (ex. -t, -> , 로 분리구분)

-u : 유일값 출력

ex)

$ sort -t: -k1 -r /etc/passwd -> /etc/passwd 파일을 : 으로 구분하여 첫 번쨰 필드 기준으로 정렬 수행

$ ls -l | sort -k -nr -> ls -l 결과를 탭으로 구분하여 다섯번째 필드 (파일크기) 역순 정렬

$ tail -n +2 emp.csv | sort -t, -k3 -> emp.csv 파일 첫 줄을 제외한 대상을 세 번쨰 필드 순서대로 정렬

$ cut -d, -f3 emp.csv | sort -u -> emp.csv 파일을 ,로 구분하여 세번째 필드의 유일값 출력

(base) itwill@ubuntu:~/linux_ex/ch9$ head -3 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin

(base) itwill@ubuntu:~/linux_ex/ch9$ sort -t: /etc/passwd
_apt:x:42:65534::/nonexistent:/usr/sbin/nologin
avahi:x:103:109:Avahi mDNS daemon:/run/avahi-daemon:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
_chrony:x:988:988:Chrony Daemon:/var/lib/chrony:/usr/sbin/nologin
colord:x:977:977:colord colour management daemon:/var/lib/colord:/usr/sbin/nologin
...

파일 크기 순으로 정렬을 해보도록 한다.

옵션에 인수가 들어가는 경우는 한 번 띄워서 쓴다. (그렇지 않은 경우 붙여서 사용)

(base) itwill@ubuntu:~/linux_ex/ch9$ ls -l | sort -k5 -n
total 14020
-rwxr--r-- 1 itwill itwill       8 Jul 16 11:06 test.txt
-rw-rw-r-- 1 itwill itwill      40 Jul 22 12:16 test.log
-rwxrwxr-x 1 itwill itwill      79 Jul 20 14:40 8_cron.sh
-rw-rw-r-- 1 itwill itwill      80 Jul 21 12:57 16_export2.sh
-rw-rw-r-- 1 itwill itwill     109 Jul 21 15:36 total.csv
-rw-rw-r-- 1 itwill itwill     119 Jul 21 12:58 15_export1.sh
-rw-rw-r-- 1 itwill itwill     154 Jul 21 15:08 17_python.py
-rwxr--r-- 1 itwill itwill     161 Jul 16 12:14 sh_260716.log
-rw-rw-r-- 1 itwill itwill     232 Jul 21 15:35 18_python.py
-rwxr--r-- 1 itwill itwill     242 Jul 16 12:00 2_cut.sh
-rw-rw-r-- 1 itwill itwill     251 Jul 20 20:03 12_bc.sh
-rw-rw-r-- 1 itwill itwill     303 Jul 16 15:58 4_if1.sh
-rw-rw-r-- 1 itwill itwill     320 Jul 20 20:39 13_color.sh
-rw-rw-r-- 1 itwill itwill     320 Jul 21 12:04 color.env
-rw-rw-r-- 1 itwill itwill     354 Jul 20 20:00 11_expr.sh
-rwxr--r-- 1 itwill itwill     377 Jul 16 11:34 1_grep.sh
-rw-rw-r-- 1 itwill itwill     389 Jul 20 12:15 7_head.sh
-rw-rw-r-- 1 itwill itwill     390 Jul 20 19:07 9_for1.sh
-rwxr--r-- 1 itwill itwill     480 Jul 16 14:54 3_wc.sh
-rw-rw-r-- 1 itwill itwill     597 Jul 21 12:50 14_text_color.sh
-rw-rw-r-- 1 itwill itwill     610 Jul 22 10:20 19_ipython.sh
-rw-rw-r-- 1 itwill itwill     721 Jul 20 10:44 5_backup.sh
-rw-rw-r-- 1 itwill itwill     725 Jul 20 19:35 10_for2.sh
-rw-rw-r-- 1 itwill itwill     734 Mar 30 10:07 emp.csv
-rw-rw-r-- 1 itwill itwill     767 Jul 20 11:26 6_case.sh
-rw-rw-r-- 1 itwill itwill    1721 Mar 30 10:07 card_history.csv
-rw-rw-r-- 1 itwill itwill    2147 Jul 22 13:01 20_ipython2.sh
drwxr--r-- 2 itwill itwill    4096 Jul 22 12:59 log
drwxrwxr-x 2 itwill itwill    4096 Jul 20 10:28 backup
-rw-rw-r-- 1 itwill itwill   43428 Jul 22 14:49 cron.log
-rw-rw-r-- 1 itwill itwill  239690 Jul 21 14:16 index.html
-rw-rw-r-- 1 itwill itwill 6027546 Mar 30 10:07 delivery.csv
-rw-rw-r-- 1 itwill itwill 7914024 Jul 22 11:10 delivery_new.csv

(base) itwill@ubuntu:~/linux_ex/ch9$ ls -l | sort -k5 -nr
-rw-rw-r-- 1 itwill itwill 7914024 Jul 22 11:10 delivery_new.csv
-rw-rw-r-- 1 itwill itwill 6027546 Mar 30 10:07 delivery.csv
-rw-rw-r-- 1 itwill itwill  239690 Jul 21 14:16 index.html
-rw-rw-r-- 1 itwill itwill   43475 Jul 22 14:50 cron.log
drwxrwxr-x 2 itwill itwill    4096 Jul 20 10:28 backup
drwxr--r-- 2 itwill itwill    4096 Jul 22 12:59 log
-rw-rw-r-- 1 itwill itwill    2147 Jul 22 13:01 20_ipython2.sh
-rw-rw-r-- 1 itwill itwill    1721 Mar 30 10:07 card_history.csv
-rw-rw-r-- 1 itwill itwill     767 Jul 20 11:26 6_case.sh
-rw-rw-r-- 1 itwill itwill     734 Mar 30 10:07 emp.csv
-rw-rw-r-- 1 itwill itwill     725 Jul 20 19:35 10_for2.sh
-rw-rw-r-- 1 itwill itwill     721 Jul 20 10:44 5_backup.sh
-rw-rw-r-- 1 itwill itwill     610 Jul 22 10:20 19_ipython.sh
-rw-rw-r-- 1 itwill itwill     597 Jul 21 12:50 14_text_color.sh
-rwxr--r-- 1 itwill itwill     480 Jul 16 14:54 3_wc.sh
-rw-rw-r-- 1 itwill itwill     390 Jul 20 19:07 9_for1.sh
-rw-rw-r-- 1 itwill itwill     389 Jul 20 12:15 7_head.sh
-rwxr--r-- 1 itwill itwill     377 Jul 16 11:34 1_grep.sh
-rw-rw-r-- 1 itwill itwill     354 Jul 20 20:00 11_expr.sh
-rw-rw-r-- 1 itwill itwill     320 Jul 21 12:04 color.env
-rw-rw-r-- 1 itwill itwill     320 Jul 20 20:39 13_color.sh
-rw-rw-r-- 1 itwill itwill     303 Jul 16 15:58 4_if1.sh
-rw-rw-r-- 1 itwill itwill     251 Jul 20 20:03 12_bc.sh
-rwxr--r-- 1 itwill itwill     242 Jul 16 12:00 2_cut.sh
-rw-rw-r-- 1 itwill itwill     232 Jul 21 15:35 18_python.py
-rwxr--r-- 1 itwill itwill     161 Jul 16 12:14 sh_260716.log
-rw-rw-r-- 1 itwill itwill     154 Jul 21 15:08 17_python.py
-rw-rw-r-- 1 itwill itwill     119 Jul 21 12:58 15_export1.sh
-rw-rw-r-- 1 itwill itwill     109 Jul 21 15:36 total.csv
-rw-rw-r-- 1 itwill itwill      80 Jul 21 12:57 16_export2.sh
-rwxrwxr-x 1 itwill itwill      79 Jul 20 14:40 8_cron.sh
-rw-rw-r-- 1 itwill itwill      40 Jul 22 12:16 test.log
-rwxr--r-- 1 itwill itwill       8 Jul 16 11:06 test.txt

(base) itwill@ubuntu:~/linux_ex/ch9$ cut -d, -f3 emp.csv | sort -u
ANALYST
CLERK
JOB
MANAGER
PRESIDENT
SALESMAN

(base) itwill@ubuntu:~/linux_ex/ch9$ tail -n +2 emp.csv | sort -t, -k3
7902,FORD,ANALYST,7566,1981-12-03 0:00,3000,,20
7788,SCOTT,ANALYST,7566,1987-04-17 0:00,3000,,20
7900,JAMES,CLERK,7698,1981-12-03 0:00,950,,30
7934,MILLER,CLERK,7782,1982-01-23 0:00,1300,,10
7876,ADAMS,CLERK,7788,1987-05-23 0:00,1100,,20
7369,SMITH,CLERK,7902,1980-12-17 0:00,800,,20
7566,JONES,MANAGER,7839,1981-04-02 0:00,2975,,20
7698,BLAKE,MANAGER,7839,1981-05-01 0:00,2850,,30
7782,CLARK,MANAGER,7839,1981-06-09 0:00,2450,,10
7839,KING,PRESIDENT,,1981-11-17 0:00,5000,,10
7499,ALLEN,SALESMAN,7698,1981-02-20 0:00,1600,300,30
7844,TURNER,SALESMAN,7698,1981-09-08 0:00,1500,0,30
7654,MARTIN,SALESMAN,7698,1981-09-28 0:00,1250,1400,30
7521,WARD,SALESMAN,7698,1982-02-22 0:00,1250,500,30

# 특정 단어가 존재하는 행을 제외하고 grep

(base) itwill@ubuntu:~/linux_ex/ch9$ grep -v EMPNO emp.csv
7369,SMITH,CLERK,7902,1980-12-17 0:00,800,,20
7499,ALLEN,SALESMAN,7698,1981-02-20 0:00,1600,300,30
7521,WARD,SALESMAN,7698,1982-02-22 0:00,1250,500,30
7566,JONES,MANAGER,7839,1981-04-02 0:00,2975,,20
7654,MARTIN,SALESMAN,7698,1981-09-28 0:00,1250,1400,30
7698,BLAKE,MANAGER,7839,1981-05-01 0:00,2850,,30
7782,CLARK,MANAGER,7839,1981-06-09 0:00,2450,,10
7788,SCOTT,ANALYST,7566,1987-04-17 0:00,3000,,20
7839,KING,PRESIDENT,,1981-11-17 0:00,5000,,10
7844,TURNER,SALESMAN,7698,1981-09-08 0:00,1500,0,30
7876,ADAMS,CLERK,7788,1987-05-23 0:00,1100,,20
7900,JAMES,CLERK,7698,1981-12-03 0:00,950,,30
7902,FORD,ANALYST,7566,1981-12-03 0:00,3000,,20
7934,MILLER,CLERK,7782,1982-01-23 0:00,1300,,10

04 특수기호 정의

-01 * 과 ?

- * : 자리수에 상관없이 모든

-? : 한 자리수의 모든

ex)

$ ls *.sh

$ ls a*b -> abb, accccccb 출력

$ ls a?b -> abb 출력 (세자리 파일명만 출력)

-02 []

한 자리에 표현되는 모든 값 전달 가능

$ ls a[123].txt -> a1.txt, a2.txt, a3.txt 모두 출력

-03 ~와 -

$ cd ~ -> 홈디렉토리로 이동

$ cd - -> 이전 디렉토리로 이동

-04 ''와 ""

> 일반 문자열을 감쌀 때는 구분하지 않음

> '' 안의 $, '', \, *가 무시됨 (기호 그대로를 출력함)

ex)

$ var1="abcde"

$ echo "$var1" -> abcde가 출력됨

$ echo '$var1' -> $var1이 출력됨

-05 ; 과 |

> ; : 명령어의 연속 실행

> | : 이전 명령어의 결과를 다음 명령어의 인수로 전달

ex)

$ var1=1 ; var2 =2

$ ls -l | grep -v ^- -> ls -l 결과에서 -으로 시작하는 라인을 제외하고 출력

(base) itwill@ubuntu:~/linux_ex/ch9$ cp *.sh backup

(base) itwill@ubuntu:~/linux_ex/ch9$ ls
10_for2.sh        17_python.py    4_if1.sh     card_history.csv  log
11_expr.sh        18_python.py    5_backup.sh  color.env         sh_260716.log
12_bc.sh          19_ipython.sh   6_case.sh    cron.log          test.log
13_color.sh       1_grep.sh       7_head.sh    delivery.csv      test.txt
14_text_color.sh  20_ipython2.sh  8_cron.sh    delivery_new.csv  total.csv
15_export1.sh     2_cut.sh        9_for1.sh    emp.csv
16_export2.sh     3_wc.sh         backup       index.html

(base) itwill@ubuntu:~/linux_ex/ch9$ mkdir test
(base) itwill@ubuntu:~/linux_ex/ch9$ cd test
(base) itwill@ubuntu:~/linux_ex/ch9/test$ touch a1.txt a2.txt a3.txt b1.txt b2.txt b3.txt
(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls
a1.txt  a2.txt  a3.txt  b1.txt  b2.txt  b3.txt

(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls [ab]1.txt
a1.txt  b1.txt
(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls a[123].txt
a1.txt  a2.txt  a3.txt
(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls a?.txt
a1.txt  a2.txt  a3.txt


(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls a?.txt
a1.txt  a2.txt  a3.txt
(base) itwill@ubuntu:~/linux_ex/ch9/test$ ls a*.txt
a1.txt  a2.txt  a3.txt  aaa.txt

(base) itwill@ubuntu:~/linux_ex/ch9/test$ echo "abcde"
abcde
(base) itwill@ubuntu:~/linux_ex/ch9/test$ echo 'abcde'
abcde

(base) itwill@ubuntu:~/linux_ex/ch9/test$ var1=abcde
(base) itwill@ubuntu:~/linux_ex/ch9/test$ echo $var1
abcde

(base) itwill@ubuntu:~/linux_ex/ch9/test$ echo "변수명 : $var1"
변수명 : abcde
(base) itwill@ubuntu:~/linux_ex/ch9/test$ echo '변수명 : $var1'
변수명 : $var1

05 논리 연산자

-01 and 연산자

if [ $var1 -ge 1 -a $var1 -le 100 ] # -a 가 and 연산자

혹은

if [ $var1 -ge 1 ] && [ $var1 -le 100 ]

vi 21_and.sh

#!/bin/sh

var1=100

#if [ $var1 -ge 50 -a $var -le 100 ]
if [ $var1 -ge 50 ] && [ $var1 -le 100 ]
then
  echo " 50 <= x <=100"
else
  echo "False"
fi

(base) itwill@ubuntu:~/linux_ex/ch9$ sh 21_and.sh
 50 <= x <=100

-02 or 연산자

if [ $var1 -ge 1 -o $var1 -le 100 ]

if [ $var1 -ge 1 ] || [ $var1 -le 100 ]