기록기록기룩끼룩끼룩

쿼리 계획

유정임 — Thu, 7 May 2026 18:44:16 +0900

쿼리 계획이란?

: 작성한 코드가 실제 클러스터에서 실행 가능한 저수준 연산으로 변환되는 핵심 과정으로 로지컬 플랜과 피지컬 플랜으로 이어지며, Catalyst Optimizer가 최적화를 담당

분석 → 논리적 계획 → 물리적 계획 → 코드 생성의 단계를 거쳐 입력한 코드를 즉시 실행 않고 최적의 경로를 찾음

분석 : 사용자가 작성한 SQL이나 DF 코드의 컬럼 이름, 테이블 이름 등이 실제 데이터와 일치하는지 카탈로그를 통해 확인
Logical Planning : 무엇을 할 것인지 정의
- Unresolved Logical Plan : 쿼리문의 문법 등을 확인을 하는 것으로 쿼리를 parsing 한 후 처음으로 실행
  - 이상한 특수문자나 구문적 오류가 있으면 걸러짐.
- Catalog : 테이블에 대한 정보를 저장하는 메타 데이터
- Analyzed Logical Plan(with Catalog) : 사용자가 코드 작성하면 코드가 말이 되는지 확인
  - 참조 확인 : select("col1")이라고 쓰면, 실제 col1이라는 컬럼 있는지, 테이블 이름 맞는지를 catalog통해 확인
  - 의미적 정당성 검사 : 문법뿐만 아니라 데이터 타입이 연산에 적합한지를 검사
  - 이 과정 통과하면 논리적이라고 판단되어 Analyzed Logical Plan이 됨
- Optimized Logical Plan : 논리적으로 문제가 없으면 Catalyst Optimizer가 개입해 "어떻게 하면 더 효율적으로 데이터를 처리할까"
  - Predicate 푸시다운 : 필터링 연산을 최대한 데이터 소스와 가까운 쪽으로 밀어넣는 것
    - 100만 건 다 읽은 후 10건만 고르는 것이 아니라, 읽을 때부터 조건에 맞는 10건만 가져와
  - Projection Pruning : 실제로 최종 결과에 필요한 컬럼만 골라서 읽는 것
  - Constant Folding : 실행 시점에 계산할 필요가 없는 상수 식을 미리 계
Physical Planning : 어떻게 실행할 것인지 정의
- Candidate Physical Plans : 최적화된 로지컬 플랜을 받아 실행 가능한 여러가지 후보를 만듦
  - 다양한 전략 수립 : 조인을 할때 한쪽 테이블이 작다면 모든 노드에 뿌려서 처리할지, 아니면 데이터를 다 섞어 처리할지 고민
- Cost-based Optimization : 가성비 좋은 거 선택
- Final Physical Plan : CBO를 통해 선택된 단 하나의 계획
  - 실행 지침서: 이 계획에는 Scan, Join, Shuffle 등 클러스터 전반에서 일어날 모든 물리적 연산과 순서가 명시
  - 최종 계획은 RDD의 DAG로 변환돼 실제 실행을 위해 executor로 전달
코드 생성 : 최적화된 물리적 계획을 실제 Java 바이트 코드로 변화
Adaptive Query Execution(AQE, 적응형 쿼리 실행)
1. Dynamic Shuffle Partitioning : 실제 데이터 크기에 맞춰 셔플 파티션 수를 자동으로 조절해 성능을 최적화
2. BroadCast Join Optimization : 실행 중 데이터가 충분히 작다고 판단 되면 셔플 조인을 브로드캐스트 조인으로 즉시 전환
3. Skewed Join Handling : 데이터 쏠림(Skew) 현상을 감지하고 큰 파티션을 쪼개어 연산 속도를 맞춤

SELECT * FROM large_tbl JOIN small_tbl ON id

AQE가 없으면 : 데이터들을 셔플해서 조인

AQE가 있으면 : small_tbl을 브로드캐스트로 전환 후 브로드캐스트 조인

브로드캐스트 조인?
: 작은 크기의 테이블을 드라이버에서 읽어 모든 실행 노드(executor)로 통째로 복사(broadcast)해 전달하는 조인방식
- 각 노드는 메모리에 올라온 작은 테이블과 큰 테이블의 파티션을 로컬에서 즉시 조인, 셔플 과정이 발생하지 않아 네트워킹 오버헤드가 획기적으로 줄어

spark submit와 spark api

유정임 — Thu, 7 May 2026 17:08:03 +0900

Spark submit이란?

: 내가 짠 코드를 Spark라는 엔진에 실어서 실행시키는 실행 버튼

명령어의 기본 구조

spark-submit \
  --class <메인_클래스> \
  --master <클러스터_매니저_URL> \
  --deploy-mode <배포_모드> \
  --conf <설정_키=값> \
  ... # 기타 옵션
  <애플리케이션_파일> \
  [애플리케이션_인자]

master : 스파크 작업을 어떤 환경의 자원을 빌려서 실행할 것인가

Yarn : 하둡 사용시
- 하둡 생태계에서 별도의 호스트 주소 없이 yarn이라고만 적으면 설정된 하둡 환경을 자동으로 찾음

Standalone (spark://HOST:PORT) : 스파크 자체적으로 내장된 자원 관리 기능을 사용할 때 사용
- 스파크 마스터 서버가 떠 있는 주소(HOST)와 포트(PORT)를 직접 지정해야 함. 다른 복잡한 시스템 없이 스파크만 설치된 환경에서 주로 사용
Kubernetes (k8s://HOST:PORT) : 쿠버네티스 위에서 스파크 돌릴 때 사용
- 쿠버네티스 API 서버 주소를 적어줌. 기본적으로 보안 연결(https)을 사용, 클러스터가 컨테이너 단위로 자원 할당
local : 클러스터(여러 대의 컴퓨터)가 아닌, 로컬에서 딱 하나의 worker thread만 사용해 실행
- 병렬 처리가 거의 일어나지 않아 아주 가벼움
- local[k] : k라는 숫자만큼의 일꾼 사용
- local[K,F] : k개의 일꾼을 사용하되, 작업 실패 시 최대 F번까지 다시 시도

deploy-mode : client와 cluster 두가지 버전이 있음

스파크 애플리케이션 실행 시 가장 중요한 두가지 프로세스는 드라이버와 엑시큐터
드라이버 → 지휘관, 엑시큐터 → 일꾼
deploy-mode는 Driver이 어디서 상주하느냐를 결정
- client mode : spark-submit 명령어를 실행한 컴퓨터(로컬)에서 드라이버 실행
  - 사용자가 실행 결과(로그)를 실시간 확인
  - 로컬 머신과 클러스터 사이의 네트워크 끊기면 드라이버 종료로 전체 중단
- cluster mode : 드라이버가 로컬 머신이 아닌, 클러스터 내부의 작업 노드 중 하나에서 실행
  - 로컬 머신 전원 꺼도 클러스터 안에서 작업 계속 진행
  - 운영 환경에서 데이터 파이프라인 안정적으로 돌림
  - 사용자 입장에서는 "애플리케이션 매니저(Driver)를 클러스터에 던져놓고 결과 나중에 확인

pyspark 전용 설정

--py-files : 메인 스크립트 외에 추가로 필요한 파이썬 파일, 압축된 모듈, 또는 파이썬 패키지 형태를 전달
- 분산 환경에서 다른 노드들이 내가 만든 사용자 정의 모듈을 인식할 수 있게 배달해주는 역할
--config.spark.executor.pyspark.memory : 각 executor 내에서 PySpark 전용으로 할당할 메모리 양을 설정
- 스파크는 JVM 메모리를 주로 쓰지만, PySpark는 파이썬 프로세스를 따로 뛰움. 파이썬 프로세스가 데이터를 처리할 떄 메모리가 부족해 터지는 것을 방지하기 위해 이 설정으로 "파이썬용 메모리"를 확보
--config.spark.pyspark.driver.python : 드라이버에서 사용할 파이썬 실행 파일의 경로를 지정
- 컴퓨터나 마스터 노드에 여러 버전 파이썬이 설치되어 있을 때, 정확히 어떤 버전으로 지휘할지 정해줌
--config.spark.pyspark.python : 드라이버와 엑시큐터 모두에서 사용할 파이썬 실행 파일 경로를 지정
- 클러스터 환경에서는 모든 서버의 파이썬 버전이 동일해야 함.

Spark API란?

: 개발자가 분사된 환경에서 복잡한 데이터 연산을 효율적으로 수행할 수 있도록 제공되는 인터페이스의 집합

분산 데이터 컬렉션에 대한 인터페이스 : RDD를 다루는 게 핵심으로 단일 객체를 다루듯 코드를 작성하면 API가 이를 클러스터 전체의 작업으로 변환
지연 평가 모델 : 즉시 실행이 아니라, 실행 계획을 세워두었다가 실제 결과가 필요한 시점에 한꺼번에 최적화해 실행

1. Transformations

데이터를 변형시키는 것. Spark 특성 상 데이터를 바꿀 수 없기 때문에 새로운 RDD를 만듦
lazy해서 실행 계획에 추가함
Actions이 트리거가 되어 Tranformations이 각각 실행

1-1. Transformation depdency : Transformations 발생 시, 부모 파티션의 데이터가 자식 파티션으로 어떻게 전달되는지

Narrow Dependecy : 부모 파티션과 자식 파티션이 1:1 혹은 N:1로 매핑
- n 자기 노드 안의 데이터만 읽어서 처. 다른 node와 연결을 해서 data를 셔플하지 않음.
- Direct data lineage : A→X, B →Y, C →Z 로 들어가는 파티션이 그대로 아웃 파티션으로 나온다
- Efficient execution : 네트워크 통신이 없으므로 매우 빠르고 효율적
Wide Dependency : 부모 파티션 하나가 여러 자식 파티션에 영향, 여러 부모로부터 데이터를 받아와야 함
- node간의 데이터 셔플링 해야 한다.
- Data shuffling : 그래서 네트워크 I/O가 생긴다. 네트워크 트래핑이 많이 생긴다
- Higher Cost : 데이터를 네트워크를 통해 주고 받기 때문에 비싸고 느리다.

2. Actions

기록된 모든 Transformations 과정을 실행하고, 그 결과를 driver 프로그램으로 되돌려주거나 외부 저장소에 저장
결과로 데이터셋이 아닌 실제 값(count, list 등)을 반환하거나 파일 시스템에 기록

파티션이란?

: 데이터의 쪼개진 조각으로 대용량 데이터를 처리하기 위해 데이터를 아주 작은 조각으로 나눔

분산 처리의 단위 : 스파크 클러스터에는 여러 대의 서버(워커 노드)가 있는데 각 서버는 전체 데이터 중 자신에게 할당된 몇 개의 파티션만 담당해서 처리
물리적 실체 : 메모리나 디스크에 저장되는 실제 데이터의 블록

부모 파티션과 자식 파티션??

: 연산 전 후의 관계를 부모와 자식으로 표현

RDD API

1. Transformaions

1-1. Narrow dependency : map(), mapPartion(), flatMap(), filter(), union()

1-2. Wide dependency : groupByKey(), aggregateByKey(), sortByKey(), reduceByKey(), aggregate(), join(), repartitions()

2. Actions : collect(), count(), first(), take(), reduce()

Dataframe API

1. Transformaions

1-1. Narrow dependency : select(), filter(), withColumn(), drop(), where()

1-2. Wide dependency : groupBy(), agg(), cube(), rollup(), join(), repartitions()

2. Actions : show(), head(), collect(), count(), first()

RDD API가 How(어떻게)에 집중한다면 DataFrame API는 What(무엇)에 집중하고 Spark API는 이 모든 걸 가능하게 하는 시스템 전체라고 정의 가능하다.

SparkSQL 기초(3)

유정임 — Mon, 4 May 2026 16:41:50 +0900

#lecture15_na 처리

from pyspark.sql import (
    functions as f,
    SparkSession,
    types as t
)

spark = SparkSession.builder.appName("df_missing_data").getOrCreate()
df = spark.read.csv(
    "file:///home/jovyan/work/sample/null_data.csv", header=True, inferSchema=True)
# df.show()

# DataFrame.na: Returns a DataFrameNaFunctions for handling missing values.
# DataFrame.dropna(how='any', thresh=None, subset=None)[source]: Returns a new DataFrame omitting rows with null values. DataFrame.dropna() and DataFrameNaFunctions.drop() are aliases of each other.
#   how: 'any’ or ‘all’. If ‘any’, drop a row if it contains any nulls. If ‘all’, drop a row only if all its values are null.
#   thresh: default None If specified, drop rows that have less than thresh non-null values. This overwrites the how parameter.
#   subset: optional list of column names to consider.

# df.na.drop(how="any").show()
# df.na.drop(thresh=2).show()
# df.na.drop(subset=["salary"]).show()

df.printSchema()

# # fill string
# df.na.fill("engineer").show()

# # fill integer
# df.na.fill(0).show()

# # fill the subset
# df.na.fill("NA", subset=["occupation"]).show()

# # fill the mean value
# mean_value = df.select(f.mean(df['salary'])).collect()

# # print(mean_value[0][0])

# df.na.fill(mean_value[0][0], subset=["salary"]).show()



# Date parsing
spark = SparkSession.builder.appName("df_manage_date").getOrCreate()
df = spark.read.csv(
    "file:///home/jovyan/work/sample/date_parsing.csv", header=True, inferSchema=True)

# # show year
# df.select(f.year('date')).show()

# # show month
# df.select(f.month('date')).show()

# # show day
# df.select(f.dayofmonth('date').alias('day')).show()
# df.select(f.dayofyear('date').alias('day')).show()

df = df.withColumn("year", f.year('date')).groupBy("year").mean("number").withColumnRenamed("avg(number)", "avg")
# df.show()
df.select("year", f.format_number("avg", 2).alias("avg")).show()

df.na.drop() = df.dropna
- drop(how="any") : any일 경우 row에서 어떤 값이라도 비어있으면 drop, all인 경우 row에서 모든 값이 비어있으면 drop
- drop(thresh=2) : 기존 컬럼에서 빈칸이 두개일경우에만 drop, 이건 열 기준임!
- drop(subset=["salary"]) : 해당 컬럼에 빈칸이 있을 경우 drop
df.na.fill()
- fill("fill") : 빈칸 타입이 문자열인 경우, "fill"로 채움
- fill(0) : 빈칸 타입이 정수인 경우, 0으로 채움
- fill("NA", subset=["occupation"]) : "occupation" 컬럼에 빈칸이 있는 경우 "NA" 문자열로 채움
df.select(f.mean(df['salary'])).collect() : 'salary' 컬럼의 평균값
- collect() : 클러스터의 워커 노드에 분산되어 있는 데이터를 드라이버 프로그램의 메모리로 수집해 파이썬의 리스트 형태로 변환
- mean_value의 결과는 collect()로 인해 DF의 각 행이 PySpark의 Row 객체로 변환되어 파이썬 리스트에 담김
print(mean_value[0][0])
- 첫번째 인덱스의 의미 : 리스트에서 행 추출
  - mean_value는 Row 객체들을 담고 있는 리스트
  - 해당 리스트의 첫번째 요소에 접근하기 위해 [0]을 사용
- 두번째 인덱스의 의미 : Row 객체에서 값 추출
  - Row 객체는 파이썬의 튜플처럼 인덱스를 통해 내부 값에 접근 가능
  - Row 객체 안의 첫번째 열값에 접근하기 위해 다시 [0]을 사용
df.select
- select(f.year()): 연도 추출
- select(f.month()): 월 추출
- select(f.dayofmonth()) : 날짜 추출
- select(f.dayofyear()) : 현재 날짜가 해당 연도에서 몇 일째인지

#lecture16_join

from pyspark.sql import (
    functions as f,
    SparkSession,
    types as t
)

spark = SparkSession.builder.appName("df_join").getOrCreate()

# user data
user_data = [
    ["1000", "Neville Hardy", "Apple"],
    ["2000", "Dacia Cohen", "Alphabet"],
    ["3000", "Elois Cox", "Neflix"],
    ["4000", "Junita Meyer", "Meta"],
    ["5000", "Cleora Banks", "Amazon"]]

user_col = ['id', 'name', 'company']
df_user = spark.createDataFrame(data=user_data, schema=user_col)
df_user.show()

# salary data
salary_data = [
    ["1000", "150000", "engineer"],
    ["2000", "240000", "manager"],
    ["3000", "120000", "human resource"],
    ["6000", "100000", "sales"]]

salary_col = ['id', 'salary', 'department']
df_salary = spark.createDataFrame(data=salary_data, schema=salary_col)
df_salary.show()

# # inner join: join the two dataframes on common key columns.
# # dataframe1.join(dataframe2,dataframe1.column_name ==  dataframe2.column_name,”inner”)
# print("== inner join ==")
# df_user.join(df_salary,
#                df_user.id == df_salary.id,
#                "inner").show()

# # inner join, then filter
# df_user.join(df_salary,
#                df_user.id == df_salary.id,
#                "inner").filter(df_user.id == 1000).show()

# # inner join, then where
# df_user.join(df_salary,
#                df_user.id == df_salary.id,
#                "inner").where(df_user.id == 1000).show()

# # multiple join with &
# df_user.join(df_salary,
#                (df_user.id == df_salary.id) & (df_user.id == 1000)
#             ).show()

# # full outer join: join the two dataframes with all matching and non-matching rows
# print("== full outer join ==")
# df_user.join(df_salary, 
#                df_user.id == df_salary.id, 
#                "fullouter").show()

# # left join:  joins by returning all rows from the first dataframe and only matched rows from the second one
# print("== left join ==")
# df_user.join(df_salary, 
#                df_user.id == df_salary.id, 
#                "left").show()

# # right join: joins by returning all rows from the second dataframe and only matched rows from the first one
# print("== right join ==")
# df_user.join(df_salary, 
#                df_user.id == df_salary.id, 
#                "right").show()

# # left semi join: join all rows from the first dataframe and return only matched rows from the second one
# print("== left semi join ==")
# df_user.join(df_salary, 
#                df_user.id == df_salary.id, 
#                "leftsemi").show()

# # left anti join: join returns only columns from the first dataframe for non-matched records of the second dataframe
# print("== left anti join ==")
# df_user.join(df_salary, 
#                df_user.id == df_salary.id, 
#                "leftanti").show()

# # SQL join
# df_user.createOrReplaceTempView("user")
# df_salary.createOrReplaceTempView("salary")

# spark.sql("SELECT * FROM user, salary WHERE user.id == salary.id").show()

# spark.sql("SELECT * FROM user INNER JOIN salary ON user.id == salary.id").show()

SparkSQL 기초(2)

유정임 — Mon, 4 May 2026 16:38:22 +0900

# lecture12_사용자별 최대 구하기

from pyspark.sql import (
    functions as f,
    SparkSession,
    types as t
)

spark = SparkSession.builder.appName("df_total").getOrCreate()
table_schema = t.StructType([
    t.StructField("customer_name", t.StringType(), True),
    t.StructField("product_id", t.IntegerType(), True),
    t.StructField("price", t.IntegerType(), True)])

csv_file_path = "file:///home/jovyan/work/sample/product.csv"
df = spark.read.schema(table_schema).csv(csv_file_path)

customer_spent = df.groupBy("customer_name")\
                    .agg(
                        f.round(
                            f.sum("price"),
                            2
                        ).alias("cost"))
                    
# customer_spent.show()

sorted_customer_spent = customer_spent.orderBy(f.col("cost").desc())

sorted_customer_spent.show()

df.groupBy("customer_name").agg(f.round(f.sum("price"),2).alias("cost"))
- df.groupBy("customer_name"): "customer_name" 컬럼을 기준으로 데이터를 그룹화
- agg() : 집계의 약자로, groupBy로 묶인 각 그룹에 대해 합계, 평균, 개수 등의 통계적 연산을 적용
- f.round(..., 2) : 소수점 아래 둘째 자리까지 반올림
  - price의 데이터 타입이 Integer인데 왜 필요하지???
    price가 정수 타입이지만, 향후 데이터 타입이 변경되거나 확장이 일어날때 소수점 처리를 정확히 하기 위한 안전장치
sorted_customer_spent = customer_spent.orderBy(f.col("cost").desc())
- orderBy() : sort() 메서드와 같이 기본적으로 오름차순으로 동작
- desc() : 내림차순으로 정렬

#lecture13_브로드캐스트 조인(상대적으로 작은 데이터만)

from pyspark.sql import (
    functions as f,
    SparkSession,
    types as t
)

spark = SparkSession.builder.appName("df_most_interviewed").getOrCreate()
table_schema = t.StructType([
    t.StructField("interviwer_id", t.StringType(), False),
    t.StructField("occupation_id", t.StringType(), False),
    t.StructField("rating", t.IntegerType(), False)])

csv_file_path = "file:///home/jovyan/work/sample/like.csv"
df = spark.read.schema(table_schema).csv(csv_file_path)

interviewer_count = df.groupBy("occupation_id").count().orderBy(f.desc("count"))

for d in interviewer_count.select("occupation_id", f.col("count").alias("cnt")).collect():
    print(f"{d.occupation_id}: {d.cnt}")


# But, What if we want to know what occupation_id is?  
# 1100: engineer
# 2030: developer
# 3801: painter
# 3021: chemistry teacher
# 9382: priest

meta = {
    "1100": "engineer",
    "2030": "developer",
    "3801": "painter",
    "3021": "chemistry teacher",
    "9382": "priest"
}
occupation_dict = spark.sparkContext.broadcast(meta)

def get_occupation_name(occupation_id: str) -> str:
    return occupation_dict.value[occupation_id]

occupation_lookup_udf = f.udf(get_occupation_name)

occupation_with_name = interviewer_count.withColumn("occupation_name", occupation_lookup_udf(f.col("occupation_id")))

occupation_with_name.show(10)

df.groupBy("occupation_id").count().orderBy(f.desc("count"))
- 그룹화된 데이터의 개수를 계산하여 자동으로 "count"라는 이름의 새로운 컬럼 생성
for d in interviewer_count.select("occupation_id", f.col("count").alias("cnt")).collect():
- "occupation_id"와 f.col("count")의 차이
  - f.col("occupation_id")라고 작성해도 동일하게 동작
  - f.col() 은 columns 객체로 지정해서 pyspark가 제어할 수 있는 columns 객체로 변환하는 방식으로 컬럼에 어떤 연산이나 변경을 가하고 싶을때 사용
  - f.col("count").alias("cnt") : alias()는 문자열 데이터 타입에는 존재하지 않는 pyspark column 객체만의 고유 기능으로 "count"컬럼을 f.col()로 감싸서 column 객체로 만든 후 alias 적용
spark.sparkContext.broadcast(meta) : broadcast는 대규보 분산 처리를 수행할 때 성능을 최적화
- 딕셔너리 meta를 스파크의 브로드캐스브 변수로 변환하는 역할
- 드라이버 노드에 있는 meta 데이터를 각 Executor당 딱 한 번만 전송해 메모리에 캐싱
- 이후 해당 Executor에 돌아가는 모든 Task들은 메모리에 이미 올라와 있는 이 변수를 공유해서 읽기 전용 참조
get_occupation_name(occupation_id: str) -> str
- worker node에 복사된 occupation_dict는 occupation_dict.value를 통해 원본 딕셔너리에 접근 할 수 있음
- get_occupation_name 함수 실행 시, 각 행의 occupation_id 값을 key로 사용해 value를가져옴
- occupation_id : str 는 함수가 입력받은 매개변수(occupatioon_id)의 데이터 타입이 문자열임을 명시
- -> str : 함수가 최종적으로 반환하는 값의 데이터 타입은 문자열
f.udf(get_occupation_name)
- get_occupation_name을 PySpark가 이해하고 분산 처리할 수 있는 UDF 형태로 변환하는 과정
  - 스파크 DF는 JVM 위에서 동작하는 분산 데이터 구조이고 get_occupation_name은 순수 파이썬 함수
  - f.udf()는 이 파이썬 함수를 감싸서, 스파크가 데이터를 한 행씩 처리할 때 파이썬 프로세스를 호출해 함수를 적용할 수 있도록 만들어 줌

#lecture14_csv로 추출하기

from pyspark.sql import (
    functions as f,
    SparkSession,
    types as t
)

# Attribution 3.0 Unported (CC BY 3.0)
# https://www.kaggle.com/datasets/csanhueza/the-marvel-universe-social-network

spark = SparkSession.builder.appName("df_most_popular").getOrCreate()
# csv_file_path = "file:///home/jovyan/work/sample/hero-network.csv"
# # read file
# df = spark.read\
#             .option("header", "true")\
#             .option("inferSchema", "true").csv(csv_file_path)

# # pyspark.sql.functions.collect_set(col): Aggregate function: returns a set of objects with duplicate elements eliminated.
# data = df.groupBy("hero1")\
#             .agg(
#                 f.collect_set("hero2").alias("connection"))\
#             .withColumnRenamed("hero1", "hero")
# # data.show()
# # pyspark.sql.functions.concat_ws(sep, *cols): Concatenates multiple input string columns together into a single string column, using the given separator.
# data = data.withColumn("connection", f.concat_ws(",", f.col("connection")))
# data.show()

# # DataFrame.coalesce(numPartitions): Returns a new DataFrame that has exactly numPartitions partitions.
# data.coalesce(1).write.option("header", True).csv("output")

# # load the file
csv_file_path = "file:///home/jovyan/work/output"
df = spark.read\
            .option("header", "true")\
            .option("inferSchema", "true")\
            .csv(csv_file_path)
# df.show()

# pyspark.sql.functions.size(col): Collection function: returns the length of the array or map stored in the column.
df = df.withColumn(
        "connection_size",
        f.size(
            f.split(f.col("connection"), ",")))\
        .orderBy(f.desc("connection_size"))
df.show()

most_popular_hero = df.select("hero").first()
print(most_popular_hero.hero)

df.groupBy("hero1").agg(f.collect_set("hero2").alias("connection")).withColumnRenamed("hero1", "hero")
- collect_set() : 데이터를 하나로 묶어주되, 중복을 알아서 제거해줌
  - collect_list()는 중복을 허용하고 만난 순서대로 모두 담고 collect_set()는 중복을 완전히 제거하고 고유한 값만 담음
- .withColumnRenamed() : 컬렴의 이름을 바꾸는 함수
data.withColumn("connection", f.concat_ws(",", f.col("connection"))) : 하나의 깔끔한 문자열로 변환
- 이전 단계까지 connection 컬럼안에 배열 형태로 들어가 있는 데이터를 ','를 통해 하나의 평범한 텍스트로 변환
- concat_ws: 구분자를 사용해 합치다
- withColumn() : 기존 컬럼의 값을 변경하거나 새로운 컬럼 추가할때 사용
  - 기존 배열 형태의 "connection"컬럼 내용을 가공한 문자열 데이터로 덮어 쓰기
data.coalesce(1).write.option("header", True).csv("output")
- coalesce() : 여러개로 쪼개진 데이터 조각들 다시 합치는 역할
- write: 스파크에게 데이터를 저장하겠다고 명령
- csv("output") : output이라는 파일로 저장

SparkSQL 기초(1)

유정임 — Sun, 3 May 2026 18:01:05 +0900

#lecture8

from pyspark.sql import (
    Row,
    SparkSession)
from pyspark.sql.functions import col, asc, desc

def parse_line(line: str):
    fields = line.split('|') # |
    return Row(
        name=str(fields[0]),
        country=str(fields[1]),
        email=str(fields[2]),
        compensation=int(fields[3]))


spark = SparkSession.builder.appName("SparkSQL").getOrCreate()
lines = spark.sparkContext.textFile("file:///home/jovyan/work/sample/income.txt")
income_data = lines.map(parse_line)

# Creates a DataFrame from an RDD, a list or a pandas.DataFrame.
# SparkSession.createDataFrame(data, schema=None, samplingRatio=None, verifySchema=True)[source]
schema_income = spark.createDataFrame(data=income_data).cache()

# Creates or replaces a local temporary view with this DataFrame.
schema_income.createOrReplaceTempView("income")

# returns the dataframe
medium_income_df = spark.sql(
    "SELECT * FROM income WHERE compensation >= 70000 AND compensation <= 100000")
# medium_income_df.show()

# for income_data in medium_income_df.collect():
#     # print(income_data)
#     print(income_data.name)

# # use function instead of sql function
# schema_income.groupBy("country").count().orderBy(col("count").desc()).show()

Q : 이전에 사용했던 sc = pyspark.SparkContext.getOrCreate() 와의 차이점은??

A : SparkSession은 기존의 모든 컨텍스트(SparkContext, SQLContext, HiveContext 등) 하나로 묶은 통합 진입점

SparkSession 객체 하나만 생성하면 내부적으로 SparkContext가 자동으로 생성되므로, 별도의 컨텍스트들을 관리할 필요가 없음.

spark = SparkSession.builder.appName("SparkSQL").getOrCreate()
- SparkSession.builder : 객체를 생성하기 위한 빌더 객체를 호출
- appName("SparkSQL") : 스파크 애플리케이션의 이름을 "SparkSQL"로 지정
  - 이름은 스파크 웹 UI나 클러스터 매니저에게 현재 실행 중인 작업을 모니터링할 때 식별자로 사용
schema_income = spark.createDataFrame(data=income_data).cache()
- createDataFrame : RDD를 스파크 DF로 변환(데이터의 구조를 부여)
  - RDD는 데이터를 안전하게 분산 처리하지만, 데이터 안에 어떤 칼럼이 있고 어떤 타입인지 스파크가 명확히 알지 못하는 비정형 데이터에 가까움, 이를 정형 데이터로 변환하기 위한 과정
- cache : 모든 데이터를 메모리(RAM)에 올림
  - 데이터 사이즈가 작기 때문에 메모리에 올려서 속도를 빠르게 함 : 한 번 읽어서 정형화한 DF 데이터를 메모리에 보관해서 다시 사용할 때 원본 파일을 또 읽을 필요가 없음
  - 스파크의 Lazy Evaluation 특징 : 데이터를 변환하는 작업을 즉시 실행하지 않고, 실제 결과가 필요할 때 과정 실행
schema_income.createOrReplaceTempView("income")
- createOrReplaceTempView : DF를 "income"이라는 이름의 임시 뷰로 생성하거나 교체

#lecture9_csv 파일 읽어오기1

from pyspark.sql import SparkSession
from pyspark.sql.functions import (
    avg,
    col,
    round as rnd
)

spark = SparkSession.builder.appName("sql_import_csv").getOrCreate()
csv_file_path = "file:///home/jovyan/work/sample/age.csv"

# header option: either csv has header or not(default: header = false)
# inferSchema: either all columns are str or not
data = spark.read.option("header", "true")\
            .option("inferSchema", "true")\
            .csv(csv_file_path)
# data = spark.read.option("header", "true")\
#             .csv(csv_file_path)

# # show schema
# data.printSchema()

# # show column name with data
# data.select("name", "age").show()

# # filter the data for age of 20 above
# data.filter(data.age > 20).show()

# # group by age and aggregates for count
# data.groupBy("age").count().show()

# # custom arithmetic
# data.select(data.name, data.age, data.age - 10).show()

# # column alias
# data.select(data.name, col("age").alias("age1")).show()

# # average
# data.select(data.name, data.age, data.country)\
#         .groupBy("country")\
#         .avg("age").show()

# # average & sort
# data.select(data.name, data.age, data.country)\
#         .groupBy("country")\
#         .avg("age").sort("avg(age)").show()

# # average & round
# data.select(data.name, data.age, data.country)\
#         .groupBy("country")\
#         .agg(rnd(avg("age"), 2).alias("avg_age")).show()

data = spark.read.option("header", "true").option("inferSchema", "true") .csv(csv_file_path)
- spark.read : 스파크세션에서 파일을 읽기 위한 DataFrameReader 객체 가져옴
- .option("header", "true") : csv파일의 첫번째 행을 컬럼의 이름으로 사용할 것인지 여부 결정
- .option("inferSchema", "true") : 각 컬럼에 들어있는 데이터 타입을 스파크가 자동으로 추론
  - false라면 모든 컬럼을 기본 타입인 문자열로 인식
data.select("name", "age").show()
- .select("name") : 컬럼이 name인 열만 추출
data.select(data.name, data.age, data.age - 10).show()
- 이름, 나이, 나이-10 이 추출
data.select(data.name, col("age").alias("age1")).show()
- 컬럼명을 age에서 age1으로 수정

# lecture10 _ 단어 갯수 세어보기

from pyspark.sql import (
    functions,
    Row,
    SparkSession
)

spark = SparkSession.builder.appName("df_wordcount").getOrCreate()

# # functions.explode(col)
# # Returns a new row for each element in the given array or map
# df = spark.createDataFrame([
#         Row(a=1,
#             intlist=[1,2,3],
#             mapfield={"a": "b"}
#            )])

# df.select(functions.explode(df.intlist).alias("anInt")).collect()
# # output: [Row(anInt=1), Row(anInt=2), Row(anInt=3)]


# # functions.split(str, pattern, limit=-1)
# # Splits str around matches of the given pattern.
# df = spark.createDataFrame([
#         Row(word="hello world and pyspark")])
# df.select(functions.split(df.word, ' ').alias("word")).collect()


csv_file_path = "file:///home/jovyan/work/sample/lorem_ipsum.txt"
df = spark.read.text(csv_file_path)

# # save as "value"
# df.show()

words = df.select(
    functions.explode(
        functions.split(df.value, ' ')).alias("word"))
# words.show()
word_counts = words.groupBy("word").count().orderBy(functions.col("count").desc())
# 
word_counts.show()

df = spark.createDataFrame([Row(a=1, intlist=[1,2,3], mapfield={"a": "b"})])
- Row() : 1개 행을 정의
  - a = 1 : a라는 이름의 컬럼값을 1이라고 생성
  - intlist=[1,2,3] : intlist라는 이름의 리스트 값을 [1,2,3]이라고 생성
  - mapfield={"a": "b"} : mapfield라는 이름의 딕셔너리 생성
df.select(functions.explode(df.intlist).alias("anInt")).collect()
- functions.explode(df.intlist) : 배열이나 map 형태의 컬럼을 입력받아, 그 안에 담긴 각 요소들을 개별적인 행으로 쪼개어줌
df.select(functions.split(df.word, ' ').alias("word")).collect()
- functions.split(df.word, ' ') : df의 word컬럼을 공백으로 나누고 해당 컬럼을 word라고 별칭
  - functions.split(df.word, ' ', 2) : 이 경우에는 배열의 크기를 최대 2개로 제한해서 "hello", "world and pyspark" 두개로 나눔. 기본값은 -1
words = df.select(
functions.explode(
functions.split(df.value, ' ')).alias("word"))
- df.value : 이전에 spark.read.text()에서 별도의 컬럼 이름이 없기 때문에, 자동으로 'value'라는 이름의 문자열 타입 컬럼을 생성해 모든 데이터를 집어넣음 = 파일 확장자가 .txt이든 .csv이든 spark.read.text()로 읽는 순간, df 내부에 이미 'value'라는 이름의 컬럼이 자동 생성
word_counts = words.groupBy("word").count().orderBy(functions.col("count").desc())
- .orderBy(functions.col("count").desc()) : 특정 컬럼을 기준으로 데이터를 정렬(sort와 동일)
  - functions.col() : 특정 컬럼을 객체 형태로 지정하고 제어

#lecture11 _csv 파일 읽어오기2

from pyspark.sql import (
    functions as f,
    Row,
    SparkSession,
    types as t
)

spark = SparkSession.builder.appName("df_struct").getOrCreate()

# types.StructField(name, dataType, nullable=True, metadata=None)
table_schema = t.StructType([
    t.StructField("country", t.StringType(), True),
    t.StructField("temperature", t.FloatType(), True),
    t.StructField("observed_date", t.StringType(), True)])

csv_file_path = "file:///home/jovyan/work/sample/temp_with_date.csv"
df = spark.read.schema(table_schema).csv(csv_file_path)
# df.printSchema()

data = df.select("country", "temperature", "observed_date")

min_temperature = data.groupBy("country").min("temperature")

# min_temperature.show()

# # celsius to fahrenheit: (0°C × 9/5) + 32 
f_temperature = data.withColumn(
                    "temperature",
                    (f.col("temperature") * 9 / 5) + 32)\
                .select("country", "temperature")
f_temperature.show()

※ csv 파일을 읽어올 때 헤더가 없을때 하는 방법

table_schema = t.StructType([
    t.StructField("country", t.StringType(), True),
    t.StructField("temperature", t.FloatType(), True),
    t.StructField("observed_date", t.StringType(), True)])
- t.StructType : 데이너프레임 전체의 스키마를 정의하는 컨테이너 역할
  - t : pyspark.sql,types를 축약한 표현
  - StructField(name, dataType, nullable = True, metadata = None)
    - name : 칼럼 이름
    - datatype : 데이터 타입
    - nullable = True : null 값 허용
    - metadata : 해당 컬럼에 추가적인 메타데이터를 저장할때 사용하며 생략 가능
spark.read.schema(table_schema).csv(csv_file_path)
- 이전에 헤더 있을 때 csv 읽어오는 법(spark.read.option("header", "true").csv(path))과 차이
  - read.schema는 개발자가 직접 스키마를 지정하여 읽기
  - read.option는 첫번째 줄을 컬럼의 헤더로 인식하여 읽기

DF과 SparkSQL 소개

유정임 — Fri, 1 May 2026 14:22:20 +0900

Spark Dataframe 이란?

: 기존의 pandas dataframe처럼 행과 열로 이루어진 테이블구조이지만, 내부적으로는 대용량 데이터를 여러 컴퓨터에 나누어 담아 빠르게 처리할 수 있는 분산 데이터 시스템

스파크 데이터프레임의 특징

Schema Support
- 컬럼에 대한 이름과 타입을 알기 때문에, 쉽게 접근하고 표현할 수 있음
Lazy Evaluation
- 데이터를 작업하기 전에 실현화하지 않음
Distributed and Parallel Processing
- 분산 시스템을 사용할 수 있게 함
Optimization
- 쿼리 실행 계획을 자동으로 최적화
Integration
- 추출 : DF - High level(structured) | RDD - low level(key-value pairs)
- 사용 용이성 : DF - Simple | RDD - requires more effort to use
- 사용 사례 : DF - 정형/반정형 데이터 | RDD - 비정형

SparkSQL 이란?

- 기존 SQL구문을 스파크 위에서 그대로 실행할 수 있게 해줌

SparkSQL의 이점

Ease of Use
- 기존 SQL을 알고 있다면 쉽게 사용 가능
Integration with Spark
- 쿼리 결과를 DF와 Dataset API와 쉽게 통합 가능
Performance
- optimzer가 자동으로 바꾸기 때문에 보다 빠르게 처리 가능
Flexibility
- 다양한 데이터 포맷을 처리하고 외부 데이터베이스와 통합
Unified Analytics
- 대규모 분석을 위해 SQL의 직관적인 표현력과 스파크의 강력한 분산 컴퓨팅 능력을 하나로 결합

Spark 기초(2)

유정임 — Fri, 1 May 2026 14:08:24 +0900

#lecture5_filter

# filter
# Return a new RDD containing only the elements that satisfy a predicate.

import pyspark

sc = pyspark.SparkContext.getOrCreate()
test_file = "file:///home/jovyan/work/sample/temperature.csv"

def get_data(line, header):
    if line != header:
        col = line.split(',')
        city = col[6].strip("\"")
        avg_temp_fahr = col[4]
        yield (city, avg_temp_fahr)

lines = sc.textFile(test_file)

# get header string
header = lines.first()

parsed_line = lines.flatMap(lambda line: get_data(line, header))

# filter NA values
filtered_line = parsed_line.filter(lambda x: "NA" not in x[1])

# finding min temperature
min_temp = filtered_line.reduceByKey(lambda x, y: min(float(x), float(y)))
final_list = min_temp.collect()
for city, temperature in final_list:
    print(f"{city}: {temperature}")

print("------------------")
# finding max temperature
min_temp = filtered_line.reduceByKey(lambda x, y: max(float(x), float(y)))
final_list = min_temp.collect()
for city, temperature in final_list:
    print(f"{city}: {temperature}")

첫번째 행은 행이름이 적혀 있기 때문에 추출해야 함
- header = lines.first()
  parsed_line = lines.flatMap(lambda line: get_data(line, header))
  def get_data(line, header):
  if line != header:
          col = line.split(',')
          city = col[6].strip("\"")
          avg_temp_fahr = col[4]
          yield (city, avg_temp_fahr)
  - header가 line과 다르다면 get_data 함수를 통해 튜플을 만듦
  - lines 의 결과는
    ["record_id,month,day,year,AverageTemperatureFahr,Uncertainty,City,country_id,Country", "474376,01,01,1853,NA,NA,Auckland,NEW,New Zealand", "474381,06,01,1853,51.9062,36.9572,Auckland,NEW,New Zealand", ...]
  - col은 각 한 행을 split 하고
  - city는 각행의 6번째 값을 strip하는데 이때 양 옆 큰따옴표 제거하기 위해 strip("\"")
  - yield (city, avg_temp_fahr) : 데이터를 하나씩 생성해서 보냄
    - return은 결과값을 통째로 넘겨준 뒤 함수를 종료시킨다면 yield는 하나씩 결과를 내보내면서 함수의 상태로 잠깐 멈춘채 대기하고 호출이 오면 다시 실행
  - flatMap은 함수가 반환하는 값들을 하나의 리스트로 합쳐주는 역할임
filter NA
- filtered_line = parsed_line.filter(lambda x: "NA" not in x[1])
  - 2번째 열(인덱스 1번)이 NA가 아닌 행만 필터링
최대 최소찾기
- min_temp = filtered_line.reduceByKey(lambda x, y: min(float(x), float(y)))
  final_list = min_temp.collect()
  for city, temperature in final_list:
  print(f"{city}: {temperature}")
  - x는 이미 계산된 최소 값
  - y는 새로운 값으로
  - 두개를 비교해 min/max를 계속 남겨놓는 방식

#lecture6_map_flat

# map vs. flatMap

# map transformation applies a function to each row in a DataFrame/Dataset and returns the new transformed Dataset.
# 1 => 1
# flatMap transformation flattens the DataFrame/Dataset after applying the function on every element and returns a new transformed Dataset. 
# The returned Dataset will return more rows than the current DataFrame. It is also referred to as a one-to-many transformation function
# 1 => Many
# One of the use cases of flatMap() is to flatten column which contains arrays, list, or any nested collection

import pyspark

sc = pyspark.SparkContext.getOrCreate()
rdd = sc.parallelize([("name", "joe,sarah,tom"), ("car", "hyundai")])
result = rdd.map(lambda x: x[1].split(","))
# print(result.collect())
# [['joe', 'sarah', 'tom'], ['hyundai']]

rdd = sc.parallelize([("name", "joe,sarah,tom"), ("car", "hyundai")])
result = rdd.flatMap(lambda x: x[1].split(","))
# print(result.collect())
# ['joe', 'sarah', 'tom', 'hyundai']


test_file = "file:///home/jovyan/work/sample/lorem_ipsum.txt"
lines = sc.textFile(test_file)
words = lines.flatMap(lambda x: x.split())
# word_count = words.countByValue()
# print(word_count)
# for word, count in word_count.items():
#     print(f"{word}: {count}")
    
    
# # How about sort by key?
word_count = words.map(lambda x: (x, 1)).reduceByKey(lambda x, y: x + y)
sorted_word_count = word_count.map(lambda x: (x[1], x[0])).sortByKey()
for count, word in sorted_word_count.collect():
    print(f"{count}: {word}")

map과 flatmap의 차이

flatmap은 직관적으로 하면 평평하게 만든다 → 하나의 리스트로 만든다.
map은 1개가 들어가면 1개가 나오고, flatmap은 1개가 들어가면 N개가 나온다.
map은 함수가 리스트를 반환하다면 결과물은 중첩리스트로 나옴
flatmap은 함수가 리스트를 반환하다면 내용물을 모두 꺼내서 하나의 거대한 단일 리스트로 나옴

Spark 기초(1)

유정임 — Fri, 1 May 2026 10:33:38 +0900

RDD와 DF 차이점 짚고 넘어가기

1. RDD

- 탄력적 분산 데이터 세트로 스파크의 가장 기본적인 추상화 개념

탄력적 : 데이터 처리 중 노드에 장애가 발생해도 리니지를 통해 데이터를 복구
분산된 : 클러스터의 여러 노드에 데이터가 나누어져 저장
데이터 세트 : 텍스트 파일, JSON, 객체 리스트 등의 다양한 형태의 데이터를 담을 수 있음

- 특징

데이터가 어떻게 처리되어야 하는지 개발자가 직접 제어
데이터 내부에 구조에 대한 정보가 없음 → 스파크 입장에서는 그저 객체의 묶음
컴파일 타임에 타입 체크가 가능하여 런타임 오류를 줄일 수 있음

2. DF

- RDD 위에 구축된 고수준의 추상화 모델로, 테이블과 유사

스키마 기반 : 데이터가 어떤 컬럼으로 구성되어 있고, 각 타입이 무엇인지 정의
Named Columns : 각 열에 이름이 붙어 있어 SQL 쿼리처럼 데이터를 다룰 수 있음

- 특징

select, filter, groupBy 같은 직관적인 함수를 사용
카탈리스트 옵티마이저가 실행 계획을 자동으로 최적화해 RDD보다 훨씬 빠른 성능을 냄

Spark 간단히 짚고 넘어가기

- 이전에 배운 도커가 애플리케이션을 담는 표준화된 컨테이너라면

- 스파크는 그 컨테이너들이 여러 대의 컴퓨터에서 동시에 빅데이터를 처리할 수 있게 해주는 거대한 계산기

#lecture2

import pyspark

test_file = "file:///home/jovyan/work/sample/word.txt"
# sc = pyspark.SparkContext('local[*]')
sc = pyspark.SparkContext.getOrCreate()

text_file = sc.textFile(test_file)

counts = text_file.flatMap(lambda line: line.split(" ")) \
             .map(lambda word: (word, 1)) \
             .reduceByKey(lambda a, b: a + b)
# ln1: hello,world
# (hello, 1), (world, 1), (hello, 1) => [(hello, 1), (hello, 1)], [(world, 1)]
print(counts.collect())

sc = pyspark.SparkContext('local[*]') ]
- 스파크의 환경 설정을 직접 정의하며 컨텍스트를 생성하는 명령
- local : 내 컴퓨터 - 보통 스파크는 여러 대의 컴퓨터(클러스터)를 묶어서 사용. 지금은 내 컴퓨터만 사용
- [*] : 모든 코어 사용 - CPU 안의 코어 갯수를 이용해 작업 수행
sc = pyspark.SparkContext.getOrCreate()
- SparkContext(SC) : 파이썬 코드와 스파크 엔진(클러스터)사이의 다리 역할
  - 자원관리 : 클러스터 매니저와 통신해 작업을 수행할 일꾼을 할당
  - 작업감독 : 사용자가 작성한 코드를 보고 어떻게 나누어 계산할지 계획을 세우고 지시
  - RDD 생성 : 텍스트 파일이나 리스트 데이터를 스파크가 이해할 수 있는 분산 데이터로 변환
- getOrCreate() : 가져오거나 없으면 만들어라
  - 중복 생성 방지: 스파크 내에서 하나의 SparkContext만 가질 수 있음
  - 안전 장치
- sc : pyspark.context.SparkContext 클래스의 객체
  - 마스터 노드 주소, 애플리케이션 이름, 할당된 메모리 크기 등 현재 실행 중인 스파크의 모든 환경 정보가 담김
text_file=sc.textFile(test_file)
- textFile : pyspark.context.SparkContext 클래스에 정의된 메서드
  - 이전에 만든 sc를 통해 호출
  - 외부 저장소(로컬 파일, HDFS, S3)에 있는 텍스트 데이터를 읽어와서 스파크의 기본 데이터 단위인 RDD로 변환
  - 데이터 단위 : 텍스트 파일의 한줄을 하나의요소로 취급
  - 분산 처리 : 파일 읽을 때 설정된 파티션 수에 따라 데이터를 쪼개서 클러스터의 여러 노드에 나누어 로드
  - 결과물 타입 : pyspark.rdd.RDD 타입의 객체 반환
counts = text_file.flatMap(...)
- flatMap : [1:N 변환] 으로 각 줄을 공백으로 나누어 리스트를 만든 후, 리스트들을 모두 풀어헤쳐서 하나의 거대한 단어 뭉치(RDD)로 만듦
  - 1개의 입력을 받아 0개 이상의 출력으로 확장
  - flatMap(lambda line: line.split(" ")) : textFile로 읽어온 RDD의 한 요소, 즉 텍스트 파일의 '문장 한 줄'
  - 일반 map이면 [["hello", "world"]]처럼 리스트를 포함한 리스트가 되지만, "hello"와 "world"자체가 개별 요소로 RDD로 재구성
- map : [1:1 변환]으로 단어 하나를 받아서 (단어,1)이라는 튜플로 변환
  - reduceByKey 연산을 쓰기 위해서 반드시 (키-값) 구조가 필요하기 때문에 단어가 '키', 1은 '값'
  - 단어의 개수만큼 키-값 쌍이 생성
- reduceByKey : 같은 키(단어)를 가진 값들을 하나로 합침
  - 먼저 각 파티션 내에서 같은 단어끼리 합침 → 그 다음 네트워크를 통해 다른 노드에 있는 같은 단어들을 한 곳으로 모음 → 최종적으로 모든 숫자를 더해 단어별 총합 구함
  - (a, b)에서 a와 b는 단어가 아니라 같은 키를 가진 요소들의 값
  - a : 지금까지 누적된 합계
  - b : 새로 입력된 값

#lecture3

import collections
import pyspark

test_file = "file:///home/jovyan/work/sample/grade.txt"
# sc = pyspark.SparkContext('local[*]')
sc = pyspark.SparkContext.getOrCreate()

text_file = sc.textFile(test_file)

grade = text_file.map(lambda line: line.split(" ")[1])

# Return the count of each unique value in this RDD as a dictionary of (value, count) pairs.
grade_count = grade.countByValue()

for grade, count in sorted(grade_count.items(), key=lambda item: item[1], reverse=True):
    print(f"{grade}: {count}")

grade = text_file.map(lambda line: line.split(" ")[1]
- 1:1 변환으로 text_file의 문장 한줄을 입력 받아 공백 기준으로 자름 → 결과는 리스트
- 리스트의 두번째 요소(인덱스 1)만 선택
- 원본 문장 RDD가 성적들로만 구성된 RDD로 변환되어 grade 변수에 담김
grade_count = grade.countByValue()
- countByValue() : RDD내의 각 고유한 값들이 몇 번 등장하는지를 계산
- 앞서 있었던 map+reduceByKey 조합한 거라고 생각하면 됨
- 파이썬의 딕셔너리 형태로 저장
for grade, count in sorted(...)
- grade_count.items() : 딕셔너리에 담긴 성과 개수를 (키, 값) 쌍의 리스트 형태로 꺼냄
- sorted(..., key=lambda item: item[1], reverse=True)
  - 정렬 기준 : 튜플의 두번째 요소인 빈도수를 기준으로 정렬
  - reverse=True : 내림차순

#lecture4_exp
import pyspark

sc = pyspark.SparkContext.getOrCreate()
# Key / Value RDD

# creating Key / Value RDD
total_by_brand = rdd.map(lambda brand: (brand, 1))

# # reduceByKey(): Merge the values for each key using an associative and commutative reduce function.
from operator import add
rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
sorted(rdd.reduceByKey(add).collect())
[('a', 2), ('b', 1)]


# groupByKey(): Group the values for each key in the RDD into a single sequence. Hash-partitions the resulting RDD with numPartitions partitions.
rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
sorted(rdd.groupByKey().mapValues(len).collect())
[('a', 2), ('b', 1)]
sorted(rdd.groupByKey().mapValues(list).collect())
[('a', [1, 1]), ('b', [1])]


# sortByKey(): Sorts this RDD, which is assumed to consist of (key, value) pairs.
tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
sc.parallelize(tmp).sortByKey().first()
('1', 3)


# keys(), values(): Create a RDD of keys or just values
rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
rdd.keys()
['a', 'b', 'a']

# join, rightOuterJoin, leftOuterJoin, cogroup, subtractByKey
x = sc.parallelize([("a", 1), ("b", 4)])
y = sc.parallelize([("a", 2), ("a", 3)])
sorted(x.join(y).collect())
[('a', (1, 2)), ('a', (1, 3))]


# Efficiency is the key for performance!!!
# if you only need values, use mapValues() or flatMapValues()

map : brand를 받았을 때 brand+value를 1이라고 놓고 tuple 반환
- 결과 : (brand1,1), (brand2,1), (brand1,1) ...
reduceByKey
- sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) : 파이썬의 일반적인 리스트가 RDD로 변환
  - 리스트 안의 튜플이 들어있는 형식으로 각 튜플은 두개의 요소를 가짐 →
    스파크는 자동으로 각각의 값을 key-value로 인식
- sorted(rdd.reduceByKey(add).collect())
  - reduceByKey로 인해 같은 키값을 가진 것들을 묶는다 어떻게? → add
groupByKey() : 키값을 기준으로 그룹화
- mapValues(len) : 키는 그대로 두고, 값에만 특정 함수를 적용해 변환
- groupByKey() 직후에는 ("a", [1,1]), ("b", [1]) 이렇게 묶임 이걸 len을 적용하면 각 2,1이 나옴
sortByKey() : 키 중심으로 정렬
join

#lecture4_avg

import pyspark 

sc = pyspark.SparkContext.getOrCreate()
test_file = "file:///home/jovyan/work/sample/house_price.csv"

def parse_line(line: str):
    city, price, count = line.split(',')
    return (int(price), int(count))

lines = sc.textFile(test_file)
price_count = lines.map(parse_line)
# [(10000, 3), (10000, 5), (40000, 7), (5000, 7), (4000, 2), (9000, 4), (5000, 7), (4000, 2), (8000, 9)]

sum_of_count = price_count.mapValues(lambda count: (count, 1))\
                .reduceByKey(lambda a, b: (int(a[0]) + int(b[0]), int(a[1]) + int(b[1]))) 

# ('10000', (3, 1)), ('10000', (5, 1)) ...
# [('10000', (8, 2)), ('4000', (4, 2)), ('9000', ('4', 1)), ('8000', ('9', 1)), ('40000', ('7', 1)), ('5000', (14, 2))]

avg_by_count = sum_of_count.mapValues(lambda total_count: int(total_count[0]) / total_count[1])
results = avg_by_count.collect()
print(results)

mapValues() : Key는 건드리지 않은채 Value만 작업 수행
- (10000,3)을 mapValues(lambda count: (count, 1))에 입력시
  1. 키인 10000은 따로 보관
  2. 값인 3만 lambda count : (count,1)에 집어넣음
  3. 값은 (3,1)인 튜플로 만들어짐
  4. 따로 보관했던 키와 함쳐서 ('10000',(3,1)) 반환

Spark 환경 설정

유정임 — Thu, 30 Apr 2026 18:41:33 +0900

google 창에 'databrick' 검색 후 들어가서 이메일로 가입

플랫폼에서 코드 입력해보기

1. 노트북 새로 생성하기

2. 바로 실행할 수 있음

Apache Spark 설치(window), jupyter 접속

유정임 — Thu, 30 Apr 2026 18:23:15 +0900

https://www.docker.com/

Docker: Accelerated Container Application Development

Docker is a platform designed to help developers build, share, and run container applications. We handle the tedious setup, so you can focus on the code.

www.docker.com

1. window 기반의 노트북 - 저전력 노트북이 아니기 때문에 AMD64로 다운

2. Docker Desktop 실행

3. Mac은 터미널에서 윈도우는 윈도우 파워셀 접속

4. 해당 경로에 새로운 파일 만든 다음 명령어 입력(파일명/위치는 자유, 명령어에 위치만 잘 입력하면 됨)

이 과정은 docker 환경 Jupyter로 설치+접속하는 과

docker run -it --rm -p 8888:8888 -v "C:\Users\82108\apachespark:/home/jovyan/work" jupyter/pyspark-notebook

5. 해당 링크로 들어가면 Jupyter로 접속

5-1. 터미널로 직접 docker 접속

6. 파일을 왼쪽에 드래그해서 원하는 파일 열기

# RDD 만드는 방법

import pyspark 

# class pyspark.SparkContext (
#    master = None,
#    appName = None, 
#    sparkHome = None, 
#    pyFiles = None, 
#    environment = None, 
#    batchSize = 0, 
#    serializer = PickleSerializer(), 
#    conf = None, 
#    gateway = None, 
#    jsc = None, 
#    profiler_cls = <class 'pyspark.profiler.BasicProfiler'>
# )

# Master − It is the URL of the cluster it connects to.
# appName − Name of your job.
# sparkHome − Spark installation directory.
# pyFiles − The .zip or .py files to send to the cluster and add to the PYTHONPATH.
# Environment − Worker nodes environment variables.
# batchSize − The number of Python objects represented as a single Java object. Set 1 to disable batching, 0 to automatically choose the batch size based on object sizes, or -1 to use an unlimited batch size.
# Serializer − RDD serializer.
# Conf − An object of L{SparkConf} to set all the Spark properties.
# Gateway − Use an existing gateway and JVM, otherwise initializing a new JVM.
# JSC − The JavaSparkContext instance.
# profiler_cls − A class of custom Profiler used to do profiling (the default is pyspark.profiler.BasicProfiler).

# SparkContext uses Py4J to launch a JVM and creates a JavaSparkContext. 
# By default, PySpark has SparkContext available as ‘sc’, so creating a new SparkContext won't work.

sc = pyspark.SparkContext('local[*]')

# RDD : immutable distributed collection of objects
rdd = sc.parallelize(range(1000))
rdd.takeSample(False, 5)

sc = pyspark.SparkContext('local[*]') 에서 인자가 하나라는 건 master값으로 할당, 두개면 master랑 appName 할당
한번 만들어진 RDD는 수정 불가
sc = pyspark.SparkContext('local[*]') : 환경 설정 - spark의 엔진을 내 컴퓨터(local)의 모든 자원을 사용해 가동
rdd = sc.parallelize(range(1000)) : 데이터 분산 - 메모리에 있는 일반 파이썬 리스트를 spark가 관리하는 분산 데이터(RDD)로 만드는 과정
rdd.takeSample(False, 5) - 전체 데이터 중 중복 없이(False) 임의의 데이터 5개 뽑아서 드라이버로 가져옴

RDD, Docker 소개

유정임 — Thu, 30 Apr 2026 14:10:44 +0900

RDD란?

- 스파크에서 중심이 되는 데이터셋

- Resilient Distributed Dataset : 탄력성 있는 분배된 데이터셋

- 데이터셋을 만들면 더 이상 변하지 않게 래핑해서 노드(분산시스템)로 보내는 역할

- 데이터가 여러개로 레플리카(복제) 되어있기 때문에 데이터가 잃으면 자동으로 RDD가 기존의 데이터를 restall

RDD의 주요 특징

Immutability
- 한번 만들어지면, 분산시스템에서 수정하기 어려움
- 데이터를 바꾸게 되면 새로운 RDD가 생김
Distributed
- 분산 시스템에 저장되는 데이터셋이기 때문에 수평적 프로세싱 가능
Resilience(Fault Tolerance)
Lazy Evaluation
- 파이썬에서 제너레이터역할
- 정말 필요한 순간 아니면 실행되지 않음
- collect() 혹은 save()라는 메소드가 실행되기 전까지 데이터는 lineage만 만듦, 트리거 되면 optimazed된 포맷으로 다시 만듦
Partitioned

Docker Benefits

개발 시 어디서나 똑같은 환경을 만들 수 있음
- OS, 파이썬 버전, 파이썬 라이브러리, 환경 등 포함
Usage
- Create Dockerfile
  - 특정 컨테이너 하나를 어떻게 만들지 적어 놓음, 이 설명서대로 만들면 결과는 이미지
- Create Docker Compose
  - 여러 개의 컨테이너를 어떤 규칙으로 한꺼번에 실행할지 적어놓은 기획서, 결과는 여러 개의 서비스가 동시에 작
- Run Docker Compose to start all environments

Docker 작동원리

이미지 - 프로그램이 실행되기 위해 필요한 모든 요소를 모아놓음(코드, 설정, 라이브러리)
- 이미지로는 아무것도 실행 불가하지만 이미지만 있으면 어디서든 똑같은 결과물을 만들 수 있음
컨테이너 - 이미지를 실행시킨 실제 상태
- 이미지를 이용해 만들어낸 실제 가동중인 프로그램 묶음
- 하나의 이미지로 수백개의 동일한 컨테이너 생성 가능
- 컨테이너 안에는 서로 다른 것들이 들어있지만 서로 섞이지 않음

Dockerfile 구성

FROM python:3.11.1 

ENV PYTHONUNBUFFERED 1

ARG DEV=false

COPY requirements.txt /app/
COPY requirements.dev.txt /app/
COPY app /app/

WORKDIR /app
RUN pip install -r requirements.txt

RUN if [ $DEV = true]; then pip install -r requirements.dev.txt; fi

EXPOSE 8000

FROM python:3.11.1 : 파이썬 base 이미지를 3.11.1버전으로 사용
COPY : 외부에 있는 파일을 컨테이너 안의 /app/이라는 폴더로 복사해서 사용
WORDKIR : 어떤 디렉토리를 사용하는지 선언, 이후에는 모든 커맨드가 WORKDIR안에서 이루어짐
EXPOSE : docker port를 연결시킬 수있음
Docker Compose가 작동하기 위해선 Dockerfile이 미리 준비되어있어야 함.

중간 정리

하나의 이미지로 하나의 컨테이너를 만들때 : Dockerfile → 하나의 이미지 → 하나의 컨테이너
여러개의 컨테이너로 하나의 서비스를 만들 때
: 각각의 Dockerfile로 이미지를 여러개 만듦 → 그럼 각 이미지당 한개의 컨테이너 생성 → docker-compose.yml이 이 과정들을 명령( 이때 실행뿐만 아니라, 컨테이너들의 네트워크도 자동으로 깔아줌) → dockercompose로 실행하면 하나의 서비스처럼 묶임

Docker Compose

Configuration = docker-compose.yml
- service name : 컨테이너 묶음에 붙이는 고유한 이름
- Port mapping between local and Docker : 로컬 컴퓨터의 포트와 컨테이너 내부의 포트를 연결
- Volume mapping between local and Docker : 내 컴퓨터(로컬)의 폴더와 컨테이터 내부의 폴더를 동기화, 프로그램을 수정할 때마다 매번 컨테이너를 만들 필요가 없어 작업이 매우 빨라짐

Run = docker compose 명령어
- docker compose build : Dockerfile을 이용해 이미지 빌드
- docker compose up : 이미지 Dockerframework 위에서 실행

Q : 그럼 하나의 컨테이너만 만들 때 docker-compose.yml이 필수인가??

A : 필수는 아니지만 대부분 생성함

- docker-compose.yml이 없어도 되는 경우 : 터미널에 명령어 직접 타이핑해서 실행하는 경우

- 하나뿐인데도 .yml 파일 쓰는 이유 : 자동화

docker-compose.yml 예시

version: "3.9"

services:
	app:
    	build:
        	context: .
            args:
            	- DEV = true
        ports:
        	- "8000:8000"
        volumes:
        	- ./app:/app
        command: >
        	sh -c "python manage.py runserver 0.0.0.0:8000"

services : 여러개의 서비스를 만들수 있음
app : 하나의 서비스의 이름은 'app'
build : 현재 위치(.)에 있는 Dockerfile를 찾아가라.
ports : 로컬 포트 : 컨테이너 포트 순서로 로컬 머신과 Docker머신 안에 있는 포트를 연결
volumes: 로컬 머신과 Docker 머신 안에 디렉토리 매핑
command : 컨테이너가 켜지자 마자 실행할 마지막 한마디. 현재는 Django 실행하라고 명령 중

References

https://sseozytank.tistory.com/85

클러스터&스파크 아키텍쳐 소개

유정임 — Thu, 30 Apr 2026 12:57:15 +0900

클러스터란?

- 서로 연결된 여러개의 컴퓨터(노드)를 한개의 목표를 가지고 프로세스를 하는 것

- 분산 시스템에서 가장 유명한 아파치 스파크에서는 가장 중요한 backbone같은 역할, 태스크를 받으면 작게 나눈 다음에 수행 후 결과를 한꺼번에 모은 후 사용자에게 보여줌

클러스터 종류

On-Preminss
- 회사가 직접적으로 가지고 있는 물리적 서버를 가지고 만든 클러스터
- 직접적으로 유지해야하는 단점
Cloud-Based Cluster
- 클라우드에서 가상 클러스터로 사용할때만 비용 지불
Hybrid Cluster
- 몇개 클러스터는 온프레미스로, 몇개의 클러스터는 트래픽이 올때마다 퍼블릭 클라우드로 노드를 가상으로 받음

클러스터를 이용하는 이유

Improved Performance
- 큰 데이터를 평행 프로세싱을 하기 때문에 수행 시간이 짧다
Cost Effiecieny
- 기본 PC는 하드웨어를 사용하기 때문에 슈퍼컴퓨터보다 저렴하다
Scalability
- 데이터가 많아질수록 노드를 사용할수록 수평 노드를 많이 사용해서 처리하기 쉬움
Fault Tolenrance
- 잘못될 경우 다른 노드가 자동으로 대체로 수행

클러스터 수행 방식

클러스터의 중요 요소들

Master Node
- 작업을 접수하면, 워커 노드에 임대
- 업무를 관리, 리소스 할당, 작업 스케줄
Worker Node=Slave Node
- 마스터 노드에서 업무를 받고 업무 수행
- 각 노드에는 노드 매니저가 존재 = 노드를 모니터링하는 프로세스
Cluster Manager
- 전체적인 클러스터를 계속 모니터링하고 리소스를 잘 분배하는 역할

위 그림의 Slave Node-Container-Task를 확대한 모

워커노드내의 요소들

Pyspark를 시작하는 Driver가 존재 → 이게 JVM을 생성
PySpark와 JVM 커뮤티케이션을 할 때는 Py4J 라이브러리를 이용
JVM이 또 다른 JVM을 생성
- JVM안에서 데이터를 프로세스
- Python Worker가 존재
  - PySpark를 사용하기 때문에 Python Worker가 Python 라이브러리를 가지고 있다가 JVM이 사용할 때 라이브러리에 대한 정보를 줌
- python이 새로운 라이브러리를 사용하려면 각각의 노드에 install되어있어야함. 그래서 JVM이 참조할 수 있게 Python Worker가 존재

아파치 스파크 소개

유정임 — Thu, 30 Apr 2026 10:55:15 +0900

아파치 스파크란?

- 빅데이터 위에서 쉽게, 유연하게 프로세싱 할 수 있는 툴 = 라이브러리

- 데이터 전처리를 하고 수집해서 데이터 엔지니어나 머신너링 엔지니어들이 쓰게 끔 함.

왜 아파치 스파크를 쓰는가?

High Performance
- 기존 하둡 랩리듀스는 디스크베이스로 디스크 위에서 정리를 하고 네트워크를 통해 데이터를 셔플링
- 하둡보다 더 빠름 → 모든 데이터를 메모리 위에 올린 후 메모리에서 계산을 하고 데이터 셔플링을 할 때 네트워크 사용
Unified Platform for Big Data
- 배치 프로세싱 - 시간 정해놓고 데이터 처리
- 스트림 프로세싱 - 시냇물처럼 들어오는 움직이는(?) 데이터를 처리
- SQL querying - 데이터 프레임 위에 sql을 가지고 query
- ML
- 그래프 분석
- 이 보든 걸 결합하는 싱글 시스템
  → 전체적인 걸 다 가지고 있기 때문에 다른 툴이 필요 없음
Scalability
- 클러스터(여러개의 노드를 모아놓은 것)
- 비슷한 스펙을 가진 하드웨어를 수평적으로 확장하고 네트워크를 통해 교환
- 대용량 데이터까지 처리 가능.
- 아파치 하둡 YARN, 아파치 메소스, 쿠버네티스 같은 클러스터 매니저와 같이 작동
Flexibility
- 파이썬, 자바, 스칼라, SQL, R 을 이용해서 쿼리 날릴 수 있음
- 모든 데이터(대부분 데이터는 비정형)를 데이터 포맷을 이용해 정형/반정형 데이터로 구조화
Real-Time Data Processing
- 스파크 스트리밍이라는 라이브러리를 통해 실시간 스트림(real-time data streams) 처리 가능
- 배치 프로세싱과 스트림 프로세싱을 같은 코드를 이용해 다룰 수 있음

클러스터에는 마스터 노드와 워커노드로 구성되어있음.
마스터 노드는 1~2개, 워커 노드는 여러개
1. 마스터 노드는 Driver Program이 Spark Context를 가지고 있음
2. 클러스터 매니저가 메시지를 받으면 명령을 가지고 Worker Node안에 있는 Executor에다가 Task 시킴
3. Task를 시켜서 처리 후 다시 Driver Program에 리턴
Task가 프로세싱하다가 Cache할게 있으면 저장하다가 필요하다가 다시 사용
많은 워커 노드들이 서로 셔플링하며 데이터 처리하며 분산 시스템을 만듦

왜 파이썬을 쓰는가?

Ease of Learning and Use
Rich Ecosystem
- 많은 라이브러리로 편하게 사용 가능(numpy, pandas, scikit-learn etc)
Popular Combination

백준 2804번 크로스워드 만들기

유정임 — Mon, 22 Sep 2025 08:38:46 +0900

구분 : 구현, 문자열

문제 해석

- 첫 줄에 입력되는 두 단어를 공백으로 구분

- 두 단어의 공통문자를 기준으로 크로스 -> 앞 단어는 가로로, 뒷 단어는 세로로

- 나머지는 .으로 채움

문제 풀이

2차원 행렬을 만듦 가로(첫번째 단어 길이) X 세로(두번째 단어 길이)
두 단어의 공통되는 문자 위치 찾음 -> 첫번째 단어의 n번째, 두번째 단어의 m번째라 가정
첫단어를 m번째 행에 가로로, 두번째 단어를 n번째 열에 세로로 배치
나머지는 ','으로 채워 출력

백준 4592번 중복을 없애자

유정임 — Fri, 19 Sep 2025 09:26:11 +0900

구분 : 구현

문제 해석

- 한 줄에 여러 숫자가 입력되는데 첫번째 숫자의 수만큼 숫자가 나옴

=> 리스트에 담을시 리스트 길이는 첫번째 숫자+1

- 0 출력시 반복문 종료

- 연속된 숫자는 제거

- 리스트 출력하고 마지막에 $ 추가

코드 풀이

while 반복문을 돌린다 (조건 : 0이 나올 때까지)
list에 입력 받은 숫자들을 공백으로 나누어 담는다.
2번 리스트에 첫번째 값이 0이면 조건문 종료, 아닐 시 첫번째 값 제거
list에 길이만큼 반복문을 돌리며 list의 i번째 값이 새로운 공백 리스트(final)의 마지막 값과 같으면
final리스트에 값을 넣지 않고(=pass) 같지 않다면 fianl리스트에 값 추가
final리스트 값 출력하고 '$'를 붙인다.

최종 코드

while True :
    n_list= list(map(int, input().split()))

    if n_list[0] ==  0 :
        break
    del n_list[0]

    final=[]
    for n in n_list:
        if not final or n != final[-1]:
            final.append(n)
            
    for i in final :
        print(i,end=" ")
    print("$")

웹

유정임 — Thu, 18 Sep 2025 11:41:21 +0900

1. Web Service Physical/SW Structures 요약

사용자(User): 웹 브라우저를 통해 웹 서비스를 요청함.
Web browser: 사용자의 요청(HTTP Request)을 웹 서버(Web Server)로 전달하고, 받은 응답(HTTP Response)을 표시함.
Web Server:
- 대표 예: Apache, Nginx
- 정적 페이지(HTML 등)는 직접 응답 가능.
- 동적 페이지 요청 시 웹 애플리케이션 서버(WAS)로 전달.
WAS(Web Application Server):
- 동적 페이지를 생성 (예: Django, Spring, Node.js 등)
- 필요한 경우 DB나 파일시스템과 연동
- WAS의 대표 예: Tomcat, Gunicorn(Django의 경우)
DB, FileSystem: 실제 데이터(파일, 데이터베이스)를 저장, WAS가 필요 시 접근.
Nginx + Django/Gunicorn 구조:
- Nginx가 WSGI 프로토콜로 Gunicorn(WSGI 프로세스)에 요청 전달 → Django 프레임워크에서 처리.
요약 흐름:
1. 사용자 → 웹브라우저 → (웹 서버) → WAS → DB/파일시스템 → 응답이 반대로 반환

2. HTTP란?

HTTP(HyperText Transfer Protocol)
- 웹에서 데이터를 주고받기 위해 사용하는 프로토콜(규약)
- 브라우저와 서버가 주고받는 메시지(요청/응답)의 표준 형식
- 예: 웹사이트 접속 주소(URL)가 "http://"로 시작
- 동작 예시:
  - 사용자가 브라우저에서 주소 입력 → HTTP Request 발생 → 서버가 HTTP Response로 HTML 반환

3. 하이퍼텍스트란?

하이퍼텍스트(Hypertext)
- 텍스트 내에 다른 정보(문서, 이미지, 웹페이지 등)로 연결되는 ‘링크(하이퍼링크)’가 포함된 텍스트
- 대표 예: 웹의 HTML 문서 → 다른 페이지로 이동할 수 있는 <a href="..."> 태그
- 하이퍼텍스트 개념이 웹의 핵심, 따라서 웹 페이지(HTML)는 본질적으로 하이퍼텍스트 문서임

4. 정리

웹 서비스는 클라이언트(사용자/브라우저), 웹 서버, WAS, DB/파일 등 여러 단계로 나뉨
HTTP는 이들 사이의 데이터 송수신 표준(프로토콜)
하이퍼텍스트는 링크를 포함하여 정보 간 연결성을 강조한 텍스트로, 웹의 기본 구조

HTTP Method
▷ GET - 정보 검색 ex) 게시판 리스트 불러오기

▷ POST - 실행 / 저장 ex) 회원가입 / 로그인
▷ PUT - 전체 수정 ex) 회원정보 전체 수정
▷ DELETE - 삭제 ex) 회원정보 삭제

HTTP 응답 코드

1xx : Informational - 요청 정보 처리 중

2xx : Success - 요청을 정상적으로 처리

3xx : Redirection - 요청을 완료하기 위해 추가 동작 필요

4xx : Client Error - 서버가 요청을 이해하지 못함

5xx : Server Error - 서버가 요청 처리 실패

HTML 특징

- HTML은 태그로 시작해 태그로 종료

- 태그는 Box Model

- Box : header, footer, section, article.... : 화면에 보이지 않는 것

- Item : button, a, input.... : 사용자에게 화면에 보여지는 tag

- Attribute는 같은 페이지 안에서 태그들이라도 어떤 클래스를 가지느냐에 따라 CSS를 통해 다르게 화면에 보여줄 수 있음

- attribute는 두가지 id, class

- Block:옆에 공간 있어도 배치 되지 않고, 무조건 다음 라인 => 같은 라인 배치 원할 시 :Inline

- HTML은 구조 제공, CSS는 구조를 꾸민다 => HTML과 CSS는 상호작용 하지 않음

- JS는 웹 페이지 내부에서 발생하는 동적인 기능 => JS는 HTML과 상호작용 제공

git 사용법

유정임 — Tue, 16 Sep 2025 12:49:44 +0900

$git init

: 로컬 레파지토리

$git config --global user.email "내 깃허브 주소"

3 여기까지 하면 깃허브에 내 레퍼지토리에 올라감

clone 방법 - 맨 뒤에 .은 내 현재 위치 : 집에가서 끌고 와서 수정

집에 와서 수정 후 데이터 갱신

다시 회사와서 집에서 한거 가져오기

# 프로젝트의 파일 버전 콘트롤을 위해서 local repository 생성
-> git init -> local repository
-> git config --global user.email "github에 등록한 이메일"
-> git config --global user.name "github account"

# local repository에 README.txt 파일을 생성하고, "테스트 글자"를 입력한 후, 저장
-> git add README.txt #staging area로 올려주는 것
-> git commit -m "수정된 사항된 사항 설명글1"

README.txt 파일 열고, 안에 내용을 수정하자.
-> git add README.txt
-> git commit -m "수정된 사항된 사항 설명글2"

#첫번째 commit 상태로 roll back 하고 싶은 경우
#즉, 과거로 돌아가고 싶다
# commit_number의 앞자리 숫자를 넣어주세요.
-> git chekout commit_number

#과거로 돌아온 상태에서, 다시 최근의 commit으로 돌아가고 싶다면,
-> git checkout master or main

git hub(web site) repository(rag_basic 이름으로) 생성(private)
-> 해당 repository의 URL copy
-> https://github.com/계정명/rag_basic.git

local repository와 remote repository(git hub) 연동
-> git remote add origin [git hub repo url]

local repo에 있는 2개의 commit을 remote repo로 업로드
-> 2개의 commit을 관리할 브랜치를 main이라고 할것이고,
   이를 구성하자.
   -> git branch -M main (local branch : master --> main으로 수정)
   -> 위 과정 중에 에러가 발생하면, git status 실행

-> remote repo로 던져주자.
   -> git push origin main

#집에와서 집의 pc에서 오늘작업한 github의 프로젝트를
#복제하고, synch를 맞춰보자.
#집의 pc의 local repository로 사용할 폴더를 만들자
-> C:\vs_code_prj\tmp_rag_basic
# git hub project clone을 만들자(해당 폴더에)
# 해당 폴더를 open git bash를 클릭한 상태에서(도스창에서)
-> git clone [git hub project url] .
# From : git hub project url
# To : . (명령을 내리는 현재 디렉토리)

# 코드 또는 문서를 수정하고,
# 수정된 사항을 commit시키자.
-> git commit -m "comment"

# 수정된 사항을 remote repository에 push 해서
# 최신 사항을 UpToDate 하자.
-> git push origin main

#회사에서 현재 commit2개의 과거 정보를 가지고 있기 때문에,
#최신 commit으로 update
-> git pull origin main
-> 집에서 작업한 내용이 적용되어 있는지 파일 내용 체크

머신러닝 Pt.6

유정임 — Thu, 11 Sep 2025 15:50:28 +0900

시계열데이터분석

: 균등한 간격을 두고 관측된 자료를 의미

Q: 시계열 데이터와 일반 데이터의 차이?

A: 종속변수의 변화에 영향을 미치는 주 요인이 시간이 된다는 것 = 과거와 현재의 데이터가 서로 밀접한 상관성

시계열데이터의 형태

경향(추세) : Trend
계절 : Seasonality
- Short term
순환 : Cyclic
- Long term
불규칙/요인 : Irregularity

시계열데이터를 분석의 암묵적 동의

- 시계열데이터는 서로 독립적이지 않고, 상호 연관성이 있으며, 그 연관성은 시점이 가까울수록 더 강할 것

과거를 이용한 예측(단, 정상성이 확보되야 함)

정상성(Stationarity)

: 시간 t에서 평균, 분산이 일정한 특성, 이런 특성을 가진 시계열데이터→ 정상시계열데이터

- 백색잡음의 특성

정상성 확인 방법

: 자기상관의 패턴을 이용해 정상성 확인

□ ACF(자기상관), PACF(부분자기상관)
- 동일한 변수를 시점을 달리해 관찰 → 관측값들 사이의 상호 관련된 정도를 나타내는 척도
- ACF, PACF를 통해 자기(auto=self)상관이 있는 경우 → 비정상 시계열로 판단

□ ACF

: direction, indirection path에 대한 모든 상관성에 대해 표현

- 특정 시점과 그 이전 시점 값들 사이의 모든 상관성

= 한 시점의 값이 이전의 모든 시점 값들로부터 받는 직/간접 영향을 모두 포함

□ PACF

: direction path에 대한 상관성만을 표현

- 다른 모든 중간 시점의 영향을 제거

= 오직 특정 시점의 값과 그 이전 시점의 값 사이의 순수한 직접 상관성

● 분석 방법 : 탐색적 데이터 분석 방법 → 평활법

이동평균법	지수평활법
- 분석주기를 설정하고 시계열데이터에 대해 이동평균 계산 - 결과적으로 시계열데이터의 추세를 알 수 있게 데이터 평탄화 함 - S요인과 I요인 제거하여 T요인과 C요인만으로 데이터 변환 - 모든 시점에 대해 동일한 가중치 부여	- 지수평활계수의 값 따라 현재와 과거 데이터에 대한 가중치 부여 - 불규칙변동이 큰 시계열 : 작은 지수평활계수 적용 - 불규칙변동이 작은 시계열 : 큰 지수 평활계수 적용 - 지수평활계수는 과거로 갈수록 감소

● 분석 방법 : 탐색적 데이터 분석 방법 → 분해법

: 이론적 시계열데이터를 구성요소는 4가지이지만, C와 S요인의 구분이 어려운 이유로 3가지로 나타냄

● 분석 방법 : 시계열 모형

차분(diff)
- 비정상시계열 데이터를 정상시계열로 전환하는 방법
→ n차 차분 : 현 시점(t) 데이터에서 이전 시점(t-n) 데이터를 빼는 것
자기회귀모형(AR)
: 현재의 상태가 과거의 상태에 의존한다면, 현재의 관측값을 과거의 관측값들의 함수형태로 나타낸 것
이동평균모형(MA)
: 현 시점의 관측값이 앞선 시점들의 관측 값으로 설명된다고 가정하는 자기 회귀과정과 달리, 이전 시점들이 설명해주지 못하는 오차들로 현재 시점이 설명될 수 있다고 가정
자기회귀이동평균모형(ARIMA)
- ARIMA(p, d, q)
→ p=0 : IMA(d,q)에서 d번 차분 진행하면 MA(q) 모형이 됨
→ q=0 : ARI(p,d)에서 d번 차분 진행하면 AR(p)모형이 됨

ARIMA

머신러닝 Pt.5_2

유정임 — Wed, 10 Sep 2025 12:49:54 +0900

비지도학습(Unsupervised Learning)

: 정답 라벨이 없는 데이터를 기반으로 학습

: 데이터 사이의 관계나 유사성을 기반으로 군집 별 패턴을 찾아내는 방식

■ 군집화

: 데이터의 특징, 구조 등을 통해 유사한 특성을 가진 데이터끼리 그룹화

■ 차원 축소

: 모든 특성의 정보를 최대한 유지하며, 소수의 특성 변수만 남기는 과정

: 모델의 구조를 단순화할 수 있고, 패턴의 발견이 더 수월할 수 있음

■ 추천시스템

: 연관규칙

군집화(Clustering)

:데이터의 특징, 구조 등을 통해 유사한 특성을 가진 데이터끼리 그룹화

- 이상적 군집 분석

: 군집 내 유사도는 높고(동질성), 군집 간 유사도는 낮음(이질성)

계층적 군집분석
: 계층적으로 군집 병합/분할 방식으로 군집화
비계층적 군집분석
: 미리 군집들의 수를 결정 후 군집화
- K- means 알고리즘

계층적 군집 분석

계층적 (병합) 군집부석
: 하나의 데이터로 구성된 군집에서 시작해 거리가 가까운 데이터끼리 묶어
→ 최종적으로 하나의 군집만 남을때까지 점차 병합 (Agglomerative Hierarchical Clustering)
계층적 분할 군집분석
: 데이터 간 거리가 먼 군집까지 점차적으로 나눠가며 군집 정의(Divisive Hierarchical Clustering)

▷ 최단 연결법(Single) : 군집 내 최외단에 있는 데이터 중에 가장 가까운 두 데이터 거리

▷ 최장 연결법(Complete) : 군집 내 최외단에 있는 데이터 중에 가장 멀리 떨어진 두 데이터 거리

▷ 평균 연결법(Average) : 군집 내 모든 데이터들의 거리를 평균 내 가장 짧은 군집의 거리

▷ 중심 연결볍(Centroid) : 군집 정중앙에 점을 찍어 군집 간의 거리

▷ 와드 연결법(Ward)

1. 각 군집의 중심으로부터 각 데이터 간의 거리 제곱합을 계산함( SSE)

2. 모든 군집을 하나의 군집으로 묶었을 때 오차 제곱합이 증가하는 정도를 군집의 거리로 정리

덴드로그램 : 군집분석의 과정과 결과를 시각화

계층적 군집분석의 특징

덴드로그램을 통한 군집화 과정을 확인 및 해석 용이
미리 군집의 수를 결정하지 않아도 됨
연산량이 많아 속도 느림
거리 기반의 방식으로 이상치에 민감

비계층적 군집 분석

: 미리 군집들의 수를 결정한 후에 군집화 하는 방식

- 사전에 군집들의 개수(K)를 결정 후 평균 값을 기반으로 중심(centroid)를 업데이트하면서 군집 형성

- 군집 내 유사도는 높고(동질성), 군집 간 유사도는 낮음(이질성)

군집의 개수를 의미하는 k 결정, 각 군집의 초기 중심 값 선택
각 데이터와 중심 데이터 간 거리 계산 후, 가장 가까운 중심 데이터의 군집으로 데이터 분류
중심 재배치 : 각 군집 내 데이터의 평균을 계산하면, 해당 지점이 새로운 중심값이 됨
step 2~3 반복

장점

알고리즘의 이해와 적용이 쉬움
대용량 데이터 적용 가능
항상 군집들이 나눠짐

단점

사전에 군집 수 k 결정해야 함
초기 중심 값이 중요
이상치에 영향 받을 수 있음

Elbow Method

: 군집 수에 따른 오차제곱합의 변화를 통해 최적의 k값 결정

- 적절한 군집의 수를 결정하기 위해 오차제곱합(SSE) 활용

차원 축소

: 모든 특성의 정보를 최대한 유지하며, 소수의 특성 변수만 남기는 과정

- 차원의 저주 발생

→ 고차원 공간에서 데이터를 다루고 분석할 때 나타나는 특징적 현상

- 과적합

- 차원을 계속 높이면 학습 데이터의 이상값까지도 학습 → 좋은 성능으로 인식

- 새로운 데이터 사용해 예측시 이상값까지 학습한 결과로 일반화 실패

- 차원 증가가 과적합에 미치는 영향

1. noise를 잘못 학습하게 되는 문제

2. 다중공선성 발생

3. 편중된 데이터/ 희박한 데이터

오컴의 면도날 : 경제성의 원리, 검약의 원리
많은 것들을 필요 없이 가정해서는 안 된다.
더 적은 수의 논리로 설명이 가능한 경우, 많은 수의 논리를 세우지 말라

Feature Selection(SFS 알고리즘)

- 전/후진 소거법

전진 선택 알고리즘 : 모델 향상시키거나 과적합 방지 위해 가장 유용한 특성(feature)들의 부분집합을 갖는 탐욕적 알고리즘
방법
- 비어있는 집합에서 시작해, 모델의 성능을 가장 많이 향상시키는 특성을 하나씩 추가

정사영

- 최적의 축 찾기 : PCA는 데이터의 분산이 가장 큰 방향 찾기 = 주성분 찾기

→ 데이터의 원래 정보를 최대한 많이 보존할 수 있는 새로운 축

- 정보 손실 최소화 → 정보 손실 최소화

Apriori

: “빈발 집합의 부분집합도 빈발 집합이다” (Apriori property) 라는 성질을 이용.

- 작은 빈발 집합부터 시작해 확장하면서, 최소 지지도를 만족하는 집합만 남기고 최종적으로 규칙(Confidence, Lift)을 만든다.

FP- Growth

: 후보 집합을 일일이 생성하지 않고, FP-Tree(Frequent Pattern Tree)라는 압축 구조를 이용해 빈발 패턴을 탐색

- 데이터를 FP-Tree로 압축 저장한 뒤, 트리를 재귀적으로 탐색해 빈발 항목 집합을 찾는다.

머신러닝 Pt.5_1

유정임 — Tue, 9 Sep 2025 11:48:49 +0900

K-Fold Cross Validation

Validation(검증) 데이터 셋

Training Data set
- 머신러닝 모델의 학습에 사용되는 데이터셋
Testing Data set
- 학습된 머신러닝 모델의 서비스 가능 여부를 최종 확인하는 데이터 셋
Validation Data set
- 학습된 머신러닝 모델을 성능 개선 지표로 사용되는 데이터 셋

Cross Validation(교차 검증)

- 테스트 데이터 셋만을 이용해 모델 성능 개선

테스트 데이터에만 최적화된 모델 만들어짐
최종적으로 모델의 서비스 가능 여부를 확인하는 테스트 데이터 효과 사라짐

- 여러 세트로 구성된 검증 데이터 셋 통해 성능 개선

좀 더 다양한 데이터에 최적화된 모델로 학습
테스트 데이터 셋을 이용해 모델의 최종 서비스 가능 여부 확인 가능

K-Fold Cross Validation

: 가장 보편적인 교차검증 방법

- K개의 데이터 fold를 만들어 학습과 검증 평가 반복 수행

- 전체 데이터셋 100%를 테스트셋을 검증을 위해 사용 가능

Stratified K Fold API

분류분석
- 반드시 Stratified K Fold를 사용한 교차 검증해야함
회귀분석
- 연속된 숫자 값을 예측하므로 label 데이터의 분포는 의미 없음
- K Fold를 사용한 교차 검증 수행

하이퍼파라미터 최적화

모델의 성능 개선 프로세스
- 만족할 만한 성능이 나올 때까지 학습, 검증, (하이퍼파라미터의) 개선 작업 반복
모델의 검증 결과를 확인하며 사람이 직접 조종해야 함
- 하이퍼파라미터 = 모델 학습 전 사람이 직접 설정해주는 값

KNN 정리

- K값은 미리 알려주고, 홀수로 사용함

k= 1 : 항상 과적합
k= ∞ : 평탄화 (모델이 심플해져서 예측력이 떨어진다)
optimal k를 찾는게 목적!! how? 오분류가 얼마나 나느냐 = 정확도/재현율/정밀도가 얼마나 떨어지느냐에 결정
그래프로 보는 법 1. test그래프일때 : 간극 적을 때 2. k 그래프일때: 평탄화(그래프 뚝 떨어지는 지점) 직전에 가장 수평일 때

- 이상치 탐색할 때 방법 중 하나 (박스플롯보다 고급)

- 비선형적인 특징을 가지는 데이터에도 적합

- 비모수 알고리즘 : 데이터의 분포에 대해 어떤 가정도 하지 않음

- instance-based 모델 : 학습 데이터 전체를 메모리에 저장하고 새로운 데이터가 들어왔을 때 저장 된 데이터와 비교

- lazy learning : 훈련 단계에서의 거의 아무런 연산을 수행하지 않음

▷ lazy learning이라는 것은 instance-based 모델을 만들고 비모수적 알고리즘을 이용한다 → 속도 느림

분류에 사용
- 예측하려는 데이터 주변의 가장 가까운 K개의 이웃의 클래스를 확인 해, 가장 빈도가 높은 클래스를 예측 클래스로 결정
회귀에 사용
- 예측하려는 데이터 주변의 가장 가까운 K개의 이웃의 연속적인 값을 확인해, 값들의 평균을 예측 값으로 결정

거리를 측정해 유사성 판단 →각 특정(feature)이 거리 계산에 미치는 영향이 동일하도록 함

∴ 거리를 이용하는 모델은 전처리(scaling)가 필수 : 스케일링→ 예측정확도 상승하는 거지 학습 오류를 낮추지 않음

Naive Bayes 정리

: 확률 기반

- Feature → 모두 독립적

- P(A|B) = P(B|A)·P(A) /P(B)

- 각 특성(feature)과 클래스(class)의 결합 확률을 계산해 예측을 수행

학습 데이터셋에서 해당 특성과 클래스가 함께 나타나는 횟수 기반으로 계산

if . 학습 데이터에서 특정 특성이 특정 클래스와 한번도 함꼐 나타나지 않은 경우, 결합 확률은 0

라플라스 스무딩 작동~!

모든 빈도수에 1을 더해줘서 확률이 0이 되지 않도록 보장

라플라스 스무딩(Laplace Smoothing)

: 빈도수가 0인 사건(event)의 확률을 보정하여 0이 되는 것 방지하는 방법

확률(Probability)

정의: 주어진 모수(Parameters)가 고정되어 있을 때, 특정 데이터(관측값)가 나타날 가능성.
표현: 모수 θ(예: 동전이 공정할 확률 0.5)가 주어졌을 때, 어떤 데이터(앞면 7번, 뒷면 3번)가 나올 확률.
용도: "앞으로 이런 데이터가 나올 확률은 얼마인가?"라는 예측에 주로 사용.

우도(Likelihood)

정의: 주어진 데이터(관측값)가 고정되어 있을 때, 특정 모수 값이 얼마나 타당한지를 나타내는 함수.
표현: 데이터가 정해져 있을 때, θ 값이 달라질수록 그 θ가 데이터를 설명하는 정도(적합도)가 달라짐.
용도: 모수 추정(특히 Maximum Likelihood Estimation, MLE)에서 사용.

∴ 확률과 우도는 다르다

Decision Tree(의사결정나무) 정리

- 회귀, 분류 모두 가능

- X → Y : 영향력을 수치화 시킬수 있다(feature_importance_)

영향력이 높은 것 = 분류 시 불순도(Entropy) 낮게 함

- 불순도는 Parent-Child로 트리 생성시 IG 얻을 수 있다. (IG = 부모와 자식의 간극)

∴ IG를 최대로 하는 트리 만드는 게 목적

장점

시각화 가능
자료 가공 불필요
비모수
대량의 데이터 처리 가능

단점

수학적 모델x → heuristic →전역 최적화 못 할 가능성 = 얻은 답이
- 수학적 목적 함수 기반이 아니라, 규칙 세우는 경험적(heuristic) 방법으로 작동
- heuristic : 정확한 수학적 최적해를 보장하진 않지만, 현실적으로 쓸 만한 규칙/경험 법칙을 적용
- 전역 최적화를 못 할 가능성 : 트리 학습은 탐욕적 알고리즘을 사용해 매 단계에서만 최적 선택해서
전체적으로 최적이 되지 않을 수 있음
과적합이 쉽게 발생
대량의 데이터 처리 시 변수간의 관계성 발생 가능(꼭 대량의 데이터가 원인은 아니지만 대량의 데이터 처리시 가능성)

앙상블(Ensemble) 정리

voting
- 하드 보팅/ 소프트 보팅
bagging
- 여러개의 부트스트랩 만들어 동일 모델에 적용 → 보팅
- 랜덤 포레스트
boosting
- 시간에 따라 가중치를 줌
- 배깅 방식에 비해 시간 오래 걸리고, 과적합 ↑
- 약한학습에서 강한학습으로 진행되기 때문에 적절한 타이밍에 끊어야 함
- Ada, Gradient, XGB

결정트리

유정임 — Tue, 9 Sep 2025 08:55:45 +0900

결정트리란?

: '데이터를 가장 순수하게 만드는 질문'을 탐욕적으로 골라가면 나무 키우는 알고리즘

→ 얼마나 순수한가/뒤섞였는가 = 엔트로피 지수

엔트로피란?

: 클래스 분포의 무질서/불확실성 측정 값

→ 0이면 완전 순수, 최대일수록 가장 뒤 섞임

정보이득이란?

: 분할 전/후의 엔트로피 차이

- 정보이득(IG)를 최대로 만드는 분할 이용해 트리 성장

- 한 속성으로 분할 했을 때 얼마나 엔트로피가 줄었는지

IG가 큰 분할 = 불확실성 감소가 큰 분할 = 좋은 분할

scikit-learn이란?

: criterion = "gini"가 기본, "entropy", "log_loss" 선택

- 과적합 방지

max_depth
min_samples_split
min_samples_leaf
비용-복잡도 가지치기(cost-complexity pruning)

엔트로피 지수	지니 지수
순수도 증가 = 불순도 감소 지니로 시작해 엔트로피/로그로 바꿔 민감도 점검
로그를 사용하므로 이론적 의미(정보이론) 명확	계산 간단 → 속도 빠름

Step 1. “불확실성” 정량화: 엔트로피로 노드의 무질서 측정.
Step 2. “좋은 분할”의 정의: 정보이득(IG)을 최대화하는 속성·임계값 선택.
Step 3. 반복적 성장: 루트→리프까지 반복(탐욕적), 각 단계에서 엔트로피 최소화(=IG 최대화).
Step 4. 일반화 성능 보장: 사전/사후 가지치기로 과적합 억제.
Step 5. 대안 비교: 지니/엔트로피 간 트레이드오프(속도 vs 의미), 데이터에 맞춰 실험.

가지치기 조건

1. Pre-pruning (사전 가지치기, Early Stopping)

트리가 너무 깊어지기 전에 학습을 중단하는 방법
대표 조건:
- 최대 깊이(max_depth): 트리의 깊이가 특정 값을 넘으면 더 이상 분할하지 않음.
- 최소 샘플 수(min_samples_split / min_samples_leaf):
  - 분할을 수행하려면 최소 몇 개 이상의 데이터가 있어야 함.
  - 리프 노드에 최소 몇 개 이상의 데이터가 있어야 함.
- 정보 이득(IG) 최소 임계값(min_impurity_decrease):
  - 분할로 인한 불순도 감소가 특정 값보다 작으면 분할하지 않음.

2. Post-pruning (사후 가지치기)

완성된 트리에서 성능이 좋지 않은 분기(Branch)를 잘라냄
대표 조건:
- Validation Set 성능 감소 여부:
  - 가지치기 했을 때 검증 데이터 성능이 좋아지면 유지, 나빠지면 복원.
- Cost-Complexity Pruning (비용 복잡도 가지치기):
  - 리프 노드가 많아질수록 패널티를 주어 불필요하게 복잡한 트리를 줄임.
  - 대표적으로 CART 알고리즘에서 사용.

머신러닝 Pt.4

유정임 — Mon, 8 Sep 2025 09:52:09 +0900

분류 분석의 지표

: F1 score를 높이는 것

F1 score = Precision과 Recall의 조화 평균

Precision ∝ 1/ Recall

회귀 분석의 지표

: MSE, √ (MSE), MAE

분류 모델의 성능 측정

- ROC Curve

- AUC

Random Forest → Light BGM → Boosting

ROC : 모든 분류 임계값(Threshold)에서 분류 모델의 성능을 보여주는 그래프

전체 면적이 1이라고 가정했을 때,

그래프 아래의 면적을 이용

AUC score ▶ 그래프 아래의 면적이 클수록 좋다

TPR (True Positive Rate)

: Recall(양성 비율) → 클수록 높은 성능

= ROC그래프에서 Y축

= TP /(TP + FN)

FPR (False Postivie Rate)

: 허위 양성 비율 → 클수록 낮은 성능

= ROC그래프에서 X축

= FP/(TN+FP)

Threshold(임계값)

: 분류분석에서 모델이 반환한 값 기반 P/N를 판단하는 기준 값

(FPR, TPR)

AUC 값이 크면 높은 성능
- 동일 모델에서 임계값 조절해 TPR 증가시, FPR의 증가가 상대적 억제
AUC 값이 작으면 낮은 성능
- 동일 모델에서 임계값 조절해 TPR 증가시, FPR의 증가 억제 안 됨

Precision-Recall AUC

: ROC커브에서 X축과 Y축을 변경

○ X축 : FPR => Recall(TPR)

○ Y축 : TRP => Precision

- Trade Off 관계에 있는 2값을 종합하는 성능 지표로 사용

임계값 따라 TPR/FPR 값이 Trade-Off관계를 가지고 변화됨

Decision Tree와 Entropy 관계

: 엔트로피 = 0 → 100프로 분류 → 불확실성 X

: 클래스가 균등하게 섞이면 엔트로피 최대 → 불확실성 최대

엔트로피는 데이터의 혼잡도 측정
정보이득 = 엔트로피 감소량 → 결정 트리가 기준을 선택할 때 사용

∴ 결정 트리와 엔트로피는 "불확실성을 줄이는 분할 기준"으로 연결

엔트로피

: 데이터의 불확실성 또는 혼잡도를 수치로 표현

불순도가 큰 곳에서 작은 곳으로 학습 시킨다 = 정보이득(Information Gain)을 크게 하다

엔트로피를 상위에서 하위까지 작게 만든다 = IG 크게 한다.

leaf node는 gini지수(불순도)가 0이다 = 분류가 완료됐다

Pruning(가지치기)

: 오버피팅을 방지하고 모델의 일반화 성능을 향상

장점

시각화가 가능 = 이해가 쉽다
전처리가 완벽하지 않아도 가능 = 자료 가공 불필요
비모수적 방법 = 모집단에 대한 사전 정보 없이 통계적 분석이나 추론을 수행하는 방법

단점

과적합에 쉽게 빠짐
Imbalanced data에 취약
변수가 많아지면 실행(학습)시간이 증가 → 적절한 질문을 고르는 것이 중요

Q : 적절한 질문이란?

> 노드 내에서의 동질성 높음

> 노드의 순도 높음

> 노드의 불순도 낮음

불순도(Impurity), 엔트로피(Entropy) 계산

P(C1)에서 P는 확률

IG 계산 → 불순도 측정(Entropy/Gini) → 모델 학습(Fitting) → 트리 성장 → 과적합

→ 가지치기(Pruning, Early Stopping)

1. IG (Information Gain)

데이터 분할 기준을 찾기 위해 정보 이득을 계산.
분할 전후 불순도의 차이를 의미.
IG가 큰 Feature일수록 좋은 분할 기준.

2. 불순도(Impurity, Entropy/Gini)

데이터가 얼마나 섞여 있는지를 측정.
대표적인 지표:
- Entropy: −∑plog⁡p-\sum p \log p
- Gini Index: 1−∑p21 - \sum p^2
불순도가 낮아질수록 분할이 잘 된 것.

3. 모델 학습(Fitting)

선택된 Feature를 기준으로 데이터를 분할.
Leaf 노드의 불순도가 최소화될 때까지 분할을 반복.
이렇게 트리를 점점 깊게 만들어 데이터에 맞추는 과정.

4. 계속 모델 학습 유지 (Decision Tree 성장)

제약 없이 계속 분할을 반복하면 트리가 깊어짐.
훈련 데이터는 잘 설명하지만, 새로운 데이터에는 성능이 떨어질 수 있음.

5. 과적합(Overfitting)

트리가 너무 깊어져서 훈련 데이터에 지나치게 최적화되는 현상.
노이즈까지 학습하여 일반화 성능이 떨어짐.

6. 가지치기(Pruning, Early Stopping)

과적합을 방지하기 위한 과정.
방법:
- Pre-pruning (사전 가지치기): 트리 성장을 조기에 멈춤 (early stopping).
- Post-pruning (사후 가지치기): 완성된 트리에서 불필요한 가지를 잘라냄.

앙상블(Ensemble)

: 결정 트리 등의 단순한 모델을 여러 개 결합

- 단일 ML 모델보다 예측 성능 ↑

- 최신 앙상블 기법은 정형 데이터 셋 한정으로 딥러닝과 유사한 성능

Voting
Bagging
Boosting

Voting

: 서로 다른 ML 모델을, 동일한 데이터 세트로 학습

하드 보팅
- 다수의 모델이 각각 결정한 예측 값을 기반으로 최종 값으로 선정
소프트 보팅
- 다수의 모델이 각각 결정한 0, 1에 대한 예측 확률 값을 평균 내어 확률이 높은 값을 선정

Bagging(Bootstrap Aggregating)

: 전체 학습 데이터 셋에서 무작위 복원 샘플 데이터 추출

: 동일한 ML 모델을, 서로 다른 데이터 셋으로 학습. 각 학습은 독립적

Boosting

: 배깅과 유사하게 동일한 모델, 서로 다른 데이터 셋

- 학습이 순차적, 이전 단계의 학습 결과를 토대로 다음 단계 샘플링에 가중치에 결정

- 예측 성능이 가장 높지만, 속도가 느림

직렬 → 파고 파고 파다보면 모델이 암기하는 문제

Random Forest

: 배깅 기법 사용

장점

Decision Tree의 장점을 대부분 포함(모델 해석력 제외)
Decision Tree에 비해 Overfitting의 위험성이 상대적으로 적음
일 ML 모델보다 일반적으로 예측 성능이 높음

단점

느린 학습 속도
Hyperparameter 튜닝의 어려움(너무 많은 조합이 가능)

머신러닝 Pt.3

유정임 — Fri, 5 Sep 2025 16:48:24 +0900

L1 - norm : 라쏘

L2 - norm : 릿지

규제(Regularized)

: 손실함수 최소화되는 모델을 만들면서, 모델의 과대적합을 최소화

- 회귀 계수 값을 감소시켜 과대적합 개선

minRSS + Penalty

p : 독립변수 개수, w: 회귀계수

α가 0에 가까워지면 ? → 일반 회귀로 동장

α 가 무한대로 커지면? → W 값을 0에 근사하게끔

릿지

회귀계수의 제곱 값에 패널티 부여
회계 계수 값의 크기 감소시켜 과적합 개선

제곱값

라쏘

회귀계수의 절대값에 패널티를 부여
불필요한 회귀 계수를 0에 근사하도록 함
Feature Selection의 목적

절대값

로지스틱 회귀(Logistic Regression)

: 선형 회귀 방식을 분류 분석에 적용한 알고리즘

- 주로 이진 분류 문제에 사용되지만, 다중 클래스 분류에도 적용 가능

- 0과 1 사이의 반환값을 확률로 간주해 확률에 따라 분류하는 방식

분류의 이해

○ 이진분류, 데이터가 어떤 번주에 속할 확률을 0~1 사이의 값으로 예측

Positive / Negative

데이터의 목적에 따라 p일수도 n일수도 있고 대부분 데이터가 적게 나타나는 부분을 p라고 함

∴ 1이 p이고 0이 n인 것은❌

로지스틱 회귀선의 손실함수(Cross - Entropy)

Y = 1인 경우 : P, Y = 0인 경우 : N

y^는 logit 확률로부터 도출한 class 값이다
회귀계수( β₀,β₁... )해당 독립변수값이 1단위 증가시 log(odds)만큼 변화
- y^ = 0.2x1 + 0.4x2 + ...
- exp(계수) → odds가 몇 배
로지스틱 회귀분석의 cost(비용 함수)는 cross entropy

오차행렬(Confusion Matrix)

정확도(Accuracy) : 1 - (잘못 예측한 것만 뺀 것)

정밀도(Precision) : 실제 P*예측 P / 예측 P

재현율(Recall) : 실제 P*예측 P / 실제 P

머신러닝 Pt.2

유정임 — Thu, 4 Sep 2025 10:29:42 +0900

Feature Scaling

: 각 데이터들의 특성을 일정한 수준으로 변환

- 머신러닝에서 모델 성능에 영향 주는 이슈

- 데이터 준비되면 스케일링 필요 여부 확인 선행

1. 표준화

평균 0, 분산 1이 되도록 데이터 배율 조정

2. 정규화

서로 다른 스케일의 데이터 통임
정해진 범위 안에서 데이터 재배치(Min Max scaling)

SMOTE( Synthetic Minority Oversampling Technique)

: 불균형 데이터셋(imbalanced dataset)에서 소수 클래스(minority class)의 샘플 수를 늘려 데이터 불균형 문제를 해결하는 데 사용되는 오버샘플링(oversampling) 기법

왼쪽 바 그래프: 초기에 A 클래스는 B 클래스보다 샘플 수가 훨씬 적은 불균형 데이터셋(imbalanced dataset) 상태입니다.
중간 부분: SMOTE 기법을 사용하여 A 클래스의 샘플 수를 늘립니다. SMOTE는 단순히 기존 샘플을 복제하는 것이 아니라, A 클래스의 기존 샘플들을 기반으로 새로운 합성(synthetic) 샘플을 생성합니다.
오른쪽 바 그래프: SMOTE를 적용한 결과, A 클래스의 샘플 수가 B 클래스와 유사한 수준으로 증가하여 **데이터 균형(data balance)**이 맞춰진 상태가 됩니다.
'KNN 보간법': 이 용어는 SMOTE가 새로운 샘플을 생성하는 구체적인 방법을 설명합니다. SMOTE는 소수 클래스 샘플 주변의 **K-최근접 이웃(K-Nearest Neighbors, KNN)**을 찾아, 원본 샘플과 이웃 샘플 사이의 공간을 **선형 보간(linear interpolation)**하여 새로운 샘성 샘플을 만듭니다. 이 과정을 통해 단순히 복제하는 것보다 다양성을 확보할 수 있습니다.

회귀(Regression)

: 변수들 간의 관계를 분석하는 통계적 절차 = 독립변수와 종속변수 간의 상관관계 분석

통계/ML

통계 → 최소제곱법

ML → 경사하강법

머신러닝 Pt.1

유정임 — Tue, 2 Sep 2025 16:43:10 +0900

1epoch : 모든 경우의 수를 다 둘러보는 경우

ex) 16만건의 기보 , 3억 4천만번의 복습 = 1epoch : 16만 건, 총 3억 4천만 epoch

인공지능이란?

: 학습, 문제 해결, 패턴 인식 등 인지 문제 해결하는 컴퓨터공학분야

인공지능의 기술 수준

Artificial Narrow Intelligence
- 좁은 영역에서 특정한 task만 가능하지만 정확도나 속도는 인간을 뛰어넘음 = 1가지만 특화 ex) 알파고
Artificial General Intelligence
- 하나의 task에서 습득한 지식을 여러 task에 적용 가능
Artificial Super Intelligence
- 인간을 뛰어넘은 성능 ex) 아이언맨의 자비스

머신러닝이란?

: 수많은 데이터로부터 기계가 학습할 수 있도록 하는 연구분야

지도학습 : 분류, 회귀
비지도학습 : 군집화, 차원축소, 추천시스템
강화학습

지도학습 : 정답 라벨이 주어진 상태에서 학습

- 분류분석 : 예측하고자 하는 값이 범주형

- 회귀분석 : 예측하고자 하는 값이 연속형

비지도학습 : 정답 라벨이 없는 데이터 기반으로 학습

- 군집분석 : 데이터의 특징, 구조 등을 통해 유사한 특성을 가진 데이터끼리 그룹화

- 준지도학습 : 라벨이 있/없 데이터 모두 사용해 학습

머신러닝의 주요 프로세스

학습 프로세스 : 학습데이터 → 머신러닝 알고리즘

↑ ↓

검증 프로세스 : 신규데이터 →학습된 모델 → 예측분류

문제정의
데이터수집
데이터전처리
특징추출
학습
검증

1. 문제 정의

: 문제를 명확히 정의하고 알고리즘 선정

: 해결할 문제(데이터의 특성)에 따라 적절한 알고리즘을 선정이 중요

2. 데이터 수집

: 데이터는 학습된 모델의 품질을 결정하는 가장 중요 요소

○ 충분히 큰 데이터

○ 대표성을 가지는 데이터

○ 고품질의 데이터

Q: 학습에 사용된 데이터를 그대로 검증에 사용할 순 없을까요?

A : 안됨

데이터셋 분할: 홀드아웃 교차 검증

오리지널 : training + testing

분할 : training + validation + testing

3. 데이터 전처리

: 데이터의 품질 결정

- 지도학습의 경우 데이터 라벨링 작업이 포함

- 비정형 데이터의 경우 다양한 전처리 작업이 선행

- 도메인에 대한 전문지식, 데이터에 대한 이해가 중요

4. 특징 추출

- Feature? 모델에 학습시킬 데이터의 특성 → 독립변수

- Class? 모델을 통해 판단 또는 예측 하고자 하는 정답 값 → 종속 변수

Q ) Feature가 많으면 좋은 모델을 만들 수 있나?

A ) 문제를 가장 잘 설명할 수 있는 핵심 변수들을 추출하는 특징 추출 과정 필요

: 데이터에 대한 도메인 지식을 활용해 특징을 만들어내는 과정 ▶ Feature Engineering

Feature Engineering

- Feature Selection (특징 선택)

- Feature Extraction (특징 추출)

- Teature Learning(특징 학습)

※Feature Selection, Feature Extraction ▶ SFS(Sequential feature Selection)

5. 학습 & 검증

- 전처리/ 특징 추출 작업이 완료된 데이터 셋을 입력으로 모델이 최적화할 때까지 반복

- 문제의 특서에 따라 다양한 검증 지표들 존재

분류 : 정확도, 정밀도, 재현률
회귀 : MSE, MAE

K-NN

유클리디안 거리(L2 거리)

맨해튼 거리(L1 거리)

민코프스키 거리 - P(Power) = 1(유클리이안) /2(맨허튼)

- 최적의 k값 정의 중요

- 데이터의 스케일이 다른 경우 정규화 과정 필요

머신러닝의 목표

: 표본 데이터를 기반으로 일반화 된 모델을 만드는 것

모집단-----------추출------→표본 데이터

최적화(학습오류) : train데이터로 학습오류 감소

- 훈련 데이터에서 최고의 성능을 내는 모델을 조정

일반화(예측오류) : test데이터로 예측오류 감소

- 모델이 이전에 학습한 적 없는 데이터에서 얼마나 잘 수행되는지를 의미

과대적합(overfitting)	과소적합(underfitting)
- 학습용 데이터셋에 모델이 지나치게 학습&최적화 - 모델의 복잡도가 높은 상태 - 과대적합을 해결하는 과정이 더 중요함	- 학습용 데이터셋에 대한 모델의 학습이 충분하지 않아, 발생하는 학습 오류 - 새로운 데이터도 충분히 설명 못함 -최적화의 오류

k = 1 → 무조건 overfitting

과대 적합 피하기

- 학습 데이터 추가 : 교차 검증

- 학습 데이터의 모델 노출 횟수 ↓

- 모델의 복잡도 ↓

▷ Feature 제거, 변환

▷ 규제 기법 사용 : Regularization 변수의 영향력 억제

- 모델 적용 (앙상블 매커니즘)

과소 적합 피하기

- 학습 시간을 증가(딥러닝)

- 모델의 복잡도 ↑

▷ Feature 추가

▷ 규제 기법 제거

- 모델을 새로 구축

데이터 전처리

누락 값 처리
이상 값 처리
데이터 인코딩
데이터 스케일링

범주형 데이터과 머신러닝 관계

▶ 통계분석에서 독립변수가 범주형인 경우, 수치형 데이터로 변환

범주형 데이터 -----------------인코딩---------------------→수치형 데이터

라벨 인코딩, 원핫 인코딩

라벨 인코딩	원핫 인코딩
; 범주형 데이터를 연속된 숫자로 변환 - 연속적인 숫자로 변환된 결과는 수치적인 의미를 의미 하지 않음 - 값의 크기에 다라 모델 성능에 영향 -순서 있는 거	; 데이터가 0과 1만 가지도록 변환(더미 변수) - 순서 없는 거
a → 0 b → 1 c → 2 d → 3 e → 4	a → 0 → [1,0,0,0,0] b → 1 → [0,1,0,0,0] c → 2 → [0,0,1,0,0] d → 3 → [0,0,0,1,0] e → 4 → [0,0,0,0,1]

## Feature Engineering

- 원시 데이터(raw data)를 다루고 있는 문제를 더 잘 표현할 수 있는 특징(feature)로 변화는 과정

- 원시 데이터의 형태를 그대로 분석하는 것보다 더 좋은 예측 결과를 얻을 수 있는 feature를 찾는 과정

- F.E 중요한 이유

- more flexibility : 사용할 모델에 적합하도록 데이터를 변형하는데 필요

- simple models : 전처리를 잘 하자 --> 모델이 단순화 (변수들이 100개 -> 10개로 함축)

- better results : 좋은 예측값을 뱉어내자.

- Feature Selection

- Feature의 중요도를 객관적으로 측정할 수 있고, 그 크기에 따라 모델에 포함되(Selection)거나 제외할 수 있다.

- 상관계수(Y에 영향을 미치는 X변수들 선택)

- 회귀 계수와 p-value (변수들의 영향력 수치화, 변수들의 유의성을 검정) ==> 통계

- 의사결정나무(Decision Tree)의 Feature Importance

- Feature가 많은 경우? 어떻게 처리해야할까?

- 문제점

- 차원의저주 -> 특정공간에 밀도가 작아지는 현상 -> 해당 변수들의 특징이 희석된다. -> 변수처리속도가 저하된다(계산비용 증가).

- 과적합 위험 -> 모델의 복잡도는 증가

- 변수간의 상관성 분석에 어려움이 증가(분산 팽창 시키는 변수들이 증가)

- 방법

- 규제화 적용(L1, L2-norm) : weight

- 상관분석 적용(Y에 영향을 적게 미치는 요소들을 제거)

- 모델을 사용(Feature Importance를 이용해 중요도가 낮은 변수 제거, SFS를 이용)

- Domain 지식활용

회귀분석

유정임 — Mon, 25 Aug 2025 12:52:51 +0900

회귀모델

X로 연속적인 숫자Y를 예측
1개 이상의 독립변수와 종속변수 간 상관 관계 모델링
모델링 : 종속 변수에 대한 독립 변수들의 상관 관계를 회귀 계수로 나타내고 회귀계수의 최적화 된 값을 학습 통해 찾음
선형 회귀분석
- Y가 1개일 때는 단변량, 그 외엔 다변량
- X가 1개 → 단순 선형 회귀, X가 2개 이상 → 다중 선형 회귀
상관분석에서 도출한 결과(상관성)로 회귀분석 통해서 인과관계를 확인

예) 마케팅 비용이 증가하면 매출이 증가하는 가? → 상관분석 + 얼마나 영향을 받는가? → 회귀분석

1/n : mean

(y- ̂)^2 : square

MSE => 오차를 최소화 시키는 function = objective function(목적 함수) = cost function(비용 함수)

여기서 나오는 x, y들을 각각 x^, y^ 역할

̂ = β₀ + β₁x^

x, y 를 다 넣어보며 값에 근사하게끔 오차가 적어지는 β₀, β₁를 구한다.

=> 이때 β₀, β₁는 optimized β₀, β₁

선형회귀분석의 목적

: 설명 + 예측

▶ 설명 => Y에 대한 설명변수/독립변수의 영향 측정

아버지의 키(X) 아들의 키(Y)
1. 상관성이 있을 때 = (X → Y) : 설명
2. 아버지의 키가 175일때 아들의 키는 몇일까? = X → Y? : 예측

단순 선형 회귀

- 회귀선을 긋는게 최종 목적

· 처음에 β₀, β₁는 랜덤한 값으로 채워짐 ( β₀ : 절편, β₁ : 기울기)

→ (Σ (y - $\hat{y}$

→ 최적의 β₀, β₁를 찾아내는 방정식

최소 제곱 추정량 = 오차 제곱합을 최소화

다중 선형 회귀

: 독립변수 2개 이상 존재

최소제곱법 - 매개변수 추정 방법

β1, β2, β3, β4는 weight

선형회귀 모델

전제 조건 : 선형성, 정규성, 등분산성, 독립성

※ 선형성 - F통계량을 가지고 pvalue 측정

모델구축 = 모델 선택 + 계수 추정

변수 선택
- 검정 이용한 방법
- 아카이케 정보기준(BIC)를 이용한 방법
: AIC가 작을 수록 좋은 모델
계수 추정
- 확률값(우도) → 우도함수 → 로그우도 → 최대우도법
- 머시러닝의 비용함수와 같다.

SST : 종속변수의 전체 분산 SSR : 독립변수가 설명한 분산

F- 검정: 회귀 모델 전체에 대한 유의성 검정
T- 검정: 각 독립변수에 대한 유의성 검정

상관관계 분석

유정임 — Mon, 25 Aug 2025 10:00:37 +0900

독립변수가 연속형, 종속변수가 연속형 → 상관관계분석

: y = ax + b (a는 B1, b는 B0)

: y = B0 + B1x1

상관분석의 목적 ?

- 변수선별 → 모델에 넣어 학습 시킬때 이용

- 인과관계를 증명하기 위한 전처리

= 인과관계 증명 전에 상관 관계 존재 여부에 대한 검정

상관관계 분석시 산점도를 통해 상관성 파악 가능

추세선의 용도

기울기를 보고자 하는 게 아님 → 점들이 추세선 주위에 얼마나 밀집해져있느냐

y : 실제값

ŷ : 기대값

ȳ : 평균

error : 점과 추세선과의 거리

그럼 산점도로 상관관계 알 수 있느냐?

→ 산점도는 정성적 관계

→ 상관관계분석은 정량적 관계를 알 수 있음 = 상관관계계수

상관성이 높다?

: 추세선 주변에 데이터들이 밀집되어 있다 = 데이터의 응집성이 높다

→ x가 y값에 영향력을 많이 끼침

= 얼마나 데이터들이 추세선에 붙어있느냐

공분산(Cov) = 공통분산 = x, y의 분산= 들어오는 값(X)에서 평균( μx)을 뺀 값의 기대값(E) (기댓값은 결국 1/n한 거와 같음)

공분산이 크다 vs 작다

→ 공분산이 작다 : 모여있다 = 상관성이 크다

∴ 표준화된 연관성 측도를 상관계수라 함 = 두 변수간의 선형관 관계의 강도를 상관계수로 표현

-1 ≤ 상관계수 ≤ 1

→ 0 ≤ |상관계수| ≤ 1 : 1에 가까울 수록 강한 상관성

상관관계의 검정

귀무가설(H0): X와 Y는 상관관계가 없다.

피어슨 상관계수

공분산 / 표준 편차의 곱

상관관계의 유의

- 인과성으로 해석함에 유의 절대 아님X

예 ) 아이스크림과 모기개체수가 증가

→ 상관성이 있는 경우 인과관계는 아님 ∴ 원인은 기온 상승

→ correlation ≠ causation (correlationa은 상관분석, causation은 회귀분석)

- 시계열데이터에서는 상관관계분석 X

통계에서의 회귀분석과 ML에서의 회귀분석의 차이점

: 통계에서는 추론이 목적, ML에서는 예측이 목적

A → B : A가 B에 영향을 주는 경우
B → A : B 가 A에 영향을 주는 경우
A, B ← C : C가 요인
우연
상관관계 → 기울기X (인과성)

피어슨 상관계수 → X : 연속형 Y : 연속형
스피어만 상관계수
→ 서열을 만듦. 순위변동으로 상관성 따짐
→ 두 연속형 변수/ 순위형 변수간의 단조 관계 측정

켄달의 타우(Kendall's Tau)
→ 범주형 데이터와 연속형 데이터에 대한 상관분석
→ 두 순위형 변수 또는 서열화 할 수 있는 데이터 간의 상관관계

상관계수	데이터 유형	관계의 종류	특징
피어슨	연속형 vs. 연속형	선형(Linear)	실제 값 사용, 정규 분포 가정, 이상치에 민감
스피어만	순위형 vs. 순위형 (또는 연속형)	단조(Monotonic)	순위 사용, 이상치에 덜 민감
켄달의 타우	순위형 vs. 순위형	순서의 일치성	일치/불일치 쌍 기반, 스피어만과 유사

통계학개론 : 추론과 검정

유정임 — Tue, 19 Aug 2025 17:52:47 +0900

중심극한정리

: "표본평균의 분포는 정규분포에 근사한다."

통계학

- 중심극한정리

- 대수의 법칙

추정

: 모수를 맞추는 것

점추정 : 하나의 값으로 맞춰보고자 하는 행위

구간추정 : 특정 구간의 값으로 맞춰보고자 하는 행위

구간추정 + 신뢰수준 : 특정 구간 안에 모수가 있다고 확신 할 수 있을까?

- 신뢰수준이 95% => 100번 추정 중에서 95번은 맞을거야

점추정 + 구간추정 + 신뢰수준 규칙

: a ± b 사이에 평균이 있을 것이고, 이것을 95% 신뢰가능하다.

n이 커지면 정밀도 높아진다.

1-a의 의미가 중요

표본집단의 통계량이 μ와 같은지 다른지 - 다르다면 얼마나 유의한지

귀무가설(H0): 지금까지 알려져 있는 주장, positive

대립가설(H1): 연구자가 표본의 정보로 밝히고자 하는 주장(검정의 목적)

기각역

= 기각영역

= H0가 기각되는 영역

유의수준 : α

오차 행렬 = 혼동행렬 = confusion matrix

		실제(Real)
		H0 True	H1 True
검정결과	H0 기각 X	올바른 의사결정	제2종 오류( β 오류)
검정결과	H0 기각	제 1종 오류( α 오류)	올바른 의사결정

가설검정 순서

귀무가설과 대립가설 설정
유의수준( α ) 결정
검정통계량 선정(Z, t, F, 카이제곱 분포 등)
각 분포표를 이용해 기각역 설정(기각역이 되는 x축상의 값을 임계치라고 함)
검정통계량 산출
검정통계량을 비교해 귀무가설의 기각여부 결정
검정결과에 따라 연구결과를 해석하고 결론 도출

모수적 통계방법의 3가지 가정

분포의 정규성
(집단 내) 변량의 동질성 = 집단 내 분산의 동질성 = 등분산성
표본집단의 데이터 척도는 등간척도 또는 비율척도 따라야 함 → 연속형 데이터

정규성 검정 종류

샤피로-윌크 검정
- 표본수(n)가 2000미만인 데이터셋에 적합한 정규성 검정
콜모고로프-스미르노프 검정
- 표본수(n)가 2000초과인 데이터셋에 적합한 정규성 검정
Q-Q Plot
- 데이터셋이 정규분포를 따르는지 판단하는 시각적 분석방법
히스토그램

Q - Q plot

: 두 확률 분포를 비교하는 확률 그림의 한 종류로, 각각의 분포의 분위수들을 2차원 평면에 시각화해 비교

t - test

t-test 의 목적

- 두 집단 이하의 평균차이 검정(=비교) → 두 집단 이상 : ANOVA(분산분석)

One Sample T-test (단일표본 t-검정)

○ 모집단의 평균이 표본 평균(우리가 알고 있는 값)과 일치하는지 검정 → 표본데이터가 하나

○ 가정사항 : 표본데이터가 정규성 만족

Two Sample T-test(독립표본 t-검정)

○ 서로 다른 두 개의 그룹 간 평균 검정 방법

○ 가정사항 : 표본데이터가 정규성, 등분산성 만족

○ 표본A의 평균, 표본 B의 평균 → 평균차이에 대한 가설 검정

○ H0 : μA = μB

Paired Sample T-test(대응표본 t-검정)

○ 연관성이 있는 두 집단의 차이값에 대한 평균 검정 방법 → 하나의 샘플(=표본 데이터)의 전후 차이

○ 가정사항 : 표본데이터가 정규성, 등분산성 만족

○ μD : 모집단A, 모집단B의 모평균의 차이

○ H0 : μD=D0 → 표본A, 표본B의 모평균의 차이가 없다.

○ 저해요인/방해요소 통제해야 결과를 신뢰할 수 있다. → 전처리가 중요

상관관계분석과 선형회귀분석은 뗄레야 뗄 수 없는 관계

ANOVA(분산분석)

: 2개 이상의 집단에 대한 평균비교

○ 가정사항 : 정규성, 등분산성, 독립성

- 총 평균을 통해 집단간 변동 산출, 그룹 하나하나 마다 그룹 평균을 통해 그룹 내 변동 산출

- 그룹내 변동 : F분포(분산비에 대한 분포)

SSB : 집단간 분산 합계 / 집단수

SSW : 집단내 분산 합계 / (전체-집단수)

귀무가설이 기각된 경우 : 평균이 다르다 => 사후검정 필요

Tukey(튜키), Bonferroni(본페르니), Scheffe(쉐피), Duncan(듀칸)

사후검정 방법

비모수 검정 - 카이제곱 검정

- 빈도를 나타내는 방법 : 분할표 또는 교차표 이용해 각 범주의 빈도 표현

(O-E)^2/E

적합도 검정
- 보통 한 개의 요인을 대상(범주형 변수 1개)
- 한 개의 명목척도 변수가 대상, 알려진 모집단의 분포를 통해 예상되는 기대도수와 실제 표본을 통해 실제로 얻어진 관측도수 사이에 어느정도 차이가 있는지 검정
독립성 검정
- 두개의 범주형 변수 간에 서로 연관성이 있는지, 독립적인지를 통계적으로 판단
- 두 개의 요인을 대상으로 함(범주형 변수 2개)
동질성 검정
- 관측값들이 정해진 범주 내에서 서로 비슷하게 나타나고 있는지를 검정

독립성 검정 vs 동질성 검정

검정의 대상에 따라 표본추출 방법이 다름

- 독립성 : 하나의 집단에서 표본을 무작위로 한 번씩 추출

- 동질성 : 여러개의 집단에서 표본을 따로 추출

○ 검정 원리 : 두 가지 명목 변수 분할표 작성 → 기대도수 산출 → 카이제곱 통계량 산출

통계학 개론 : 확률분포

유정임 — Mon, 18 Aug 2025 10:34:13 +0900

카이제곱 분포 : 분산의 분포

○ Z1, Z2,...., Zk가 k개의 서로 독립적인 확립적인 확률변수

○ 자유도 k (=n - 1) 인 카이제곱 분포, n은 변수의 개수

○ 0 미만의 값이 안 나옴

확률변수 X는 자유도가 k인 카이제곱 분포를 따른다

○ 평균 E(X) = k

○ 분산 Var(X) = 2k

○ k가 커질 수록 산포가 큰 정규분포에 수렴

F-분포 : 분산비의 분포

○ F-검정 → 회귀분석의 유의성 검정

○ F는 자유도가 (k1, k2)인 F분포를 따른다

기초통계 : 자료를 정리하고 요약하여 그 특성을 정확히 기술

통계량 : 모집단의 모수를 추정하기 위해 표본에서 계산한 추정량의 값

수치형 변수의 통계량

변이 통계량 : 데이터의 흩어짐 정도를 하나의 값으로 표현
- 변동계수(CV, coefficient of variation)
: 표준편차 만으로 한 집단의 불규칙성 밖에 알 수 없음
: 타 집단과 상대적 비교 필요 시 변도계수 사용
→ 표준편차의 상대적 비교 : 표준편차/평균
→ CV = (표준편차/평균)x100
모형 통계량 : 데이터의 치우침/뾰족함 정도를 하나의 값으로 표현
- 왜도(Skewness) : 데이터의 치우침 정도를 나타냄( 양 0 음 )
→ 산포도의 외형적인 특징을 보다 잘 설명
- 첨도(Kurtosis) : 뾰족한 정도
→ 데이터들이 얼마나 평균에 집중되어 있는지 확인
→ 첨도 > 0 = 분포의 꼬리가 정규분포보다 두껍다. = t분포를 따르는 데이터의 첨도는 양수
위치 통계량 : 중심위치를 하나의 값으로 표현
- 평균 : 대표적인 자료 중심의 척도
- 중앙값 : 이상값에 영향 적음, n이 홀수 : (n+1)/2, n이 짝수 : (n + (n+1))/2
- 최빈값 : 빈도수가 최대, 평균에 영향 X
- 절사평균 : 최저, 최대값 제외한 평균
- 사분위수와 범위
: 사분위수는 위치 통계량 범위는 변이 통계량

범주형 변수의 통계량

빈도 : 변수 각각의 카운팅 값
상대빈도 : 변수 각각의 카운팅 비율

일변량 : 변수 1개, 다변량 : 변수 2개

수치형 변수를 변주형 변수로 변환하는 법

데이터 정리

도수분포표
- 자료를 한 변수가 가질 수 있는 값들의 계급 또는 범주로 나누고 각 계급에 속하는 측정치의 도수를 나타냄
= 구간화(binning, 연속형 →범주형으로변환)
상대도수
- 각 계급의 도수가 총 도수에서 차지하는 비율
히스토그램
- 가로축 : 계급, 세로축 : 도수

다변량 차트

○ 상자그림 : 범주형-수치형

- 상자그림은 이상값에 민감(이상값에 제일 민감한 값은 평균)

○ 막대그래프

○ 수치형- 수치형 : 산점도

방문빈도와 총매출액의 상관성

알 수 있는 것들
1. 트렌드(추세)

2. 밀도

3. 이상값

4. 분류에 영향을 미치는 기준값(해당 그래프에서는 방문빈도)

통계학개론 : 데이터

유정임 — Wed, 13 Aug 2025 15:20:44 +0900

1. 모집단과 표본

DW&DM

1. 데이터 소스 = 실시간으로 데이터 수집

2. staging area = DW 직전에 있는 임시 저장소/ 노이즈 확인 및 처리

3. DW = 통합, 시계열성, 주제지향성, 비휘발성

4. DM(optional) = 고객에게 이해하기 쉬운 형태로 나누겠다(=카테고리별로 나눠서)

→ 비즈니스 기능에 따라 데이터 큐브를 만든다.

· 공간분석(QGIS)

= 지도 위에 데이터의 특성을 나타내는 방법

· 탐색적 자료 분석(EDA)

= 데이터를 통해 찾고자 하는 특징, 패턴 → 시각화로 찾음

○ 분석하고자 하는 데이터 즉 변수들이 가지는 연속형 또는 문자형 데이터들의 시각화를 통해 해당 변수의 분포 또는 관계 및

특징을 찾아내는 방법

○ 데이터 → 전처리 → 시각화 → 의사결정

○ 시각화 how? 데이터에 따라 방법 달라짐

예 ) 데이터의 상관성, 데이터의 분포

· 통계분석 → 모형에 따라 달라짐

○ 기술통계 분석 : 모집단으로부터 표본 추출, 기초통계량으로 데이터분석

○ 추론통계 분석 : 모집단의 특징을 기초통계량으로 추정하는 데이터분석

· 데이터마이닝

○ 대량의 데이터에서 의미 있는 정보를 추출

○ 새로운 상관관계, 패턴, 추세 등을 탐색, 이를 모형화해 미래에 대한 예측

통계량은 표본통계량

추론(추정) : 표본의 통계량으로 모수 를 맞추고 싶을 때 하는 행위

통계학이란?

→ 모집단의 특징을 표본통계량으로 추정(추론)하는 것

2. 표본추출 방법

단순무작위(단순임의) 추출법 : 랜덤으로 뽑기
층화(표본) 추출법 : 몇 개의 층으로 나눈 후, 각 층의 데이터 비율만큼 단순무작위 추출
→ k개의 군집을 나눠도 k개의 모든 군집 내에서도 처음 비율을 깨트리지 않음
계통 추출법 : 군집간 이질성, 군집내 동질성
→ 패턴을 가지게 되는 경우, 모집단의 특성을 하나도 반영하지 못하는 결과
군집(집락) 추출법 : 군집간 동질성, 군집내 이질성

3. 표본데이터 형태

X변수 → Y변수

독립변수 → 종속변수

설명변수 → 반응변수

예측변수 → 결과변수

변수의 타입

→ 하나의 변수는 여러가지 척도로 표현 가능

→ 척도에 따라 데이터 분석 방법이 달라짐

범주형이면 빈도/교차분석, 연속형이면 분포분석

※척도 : 변수가 가지는 데이터 값들의 데이터 타입

이산형

명목변수 : 순서 없고, 크고 작음을 판단할 수 없음
서열변수 : 순서를 가짐

연속형

구간변수 : 측정치 간격에 의해 비교할 수 있도록 단위가 정해짐(절대적 0이 없다)
비율변수 : 가장 높은 수준의 척도로 4칙연산이 가능(절대적 0이 있다)

4. 확률 및 분포

확률 : 어떤 사건이 발생할 가능성을 0~1 사이의 숫자로 표현한 것
확률 실험 : 결과가 랜덤한 실험
확률모형(모델) : 확률 실험에 대한 수리적 모형
표본공간: 확률실험에서 가능한 모든 사건의 결과를 모아둔 집합
사건 : 표본공간이 정의되면 그 안에 있는 원소들 중에서 일부에 해당하는 즉, 표본공간의 부분집합을 의미

확률변수란?

어떤 값을 어느 정도의 가능성으로 취하는 가는 거기에 정해진 확률에 의해 나타남

기댓값 : 분포의 무게중심, 중심위치(=평균)

→ 계산 쉽지만 이상값에 대한 영향이 큼

평균의 종류 : 산술평균, 기하평균, 조화평균, 가중평균

조화 평균 : ML에서 많이 사용, 어디 하나 치우치지 않게
가중 평균 : 시계열데이터(MA)에서 많이 사용
산술 평균 : 1/n
기하 평균 : 경제 성장율에서 많이 사용

분산 : 분포의 산포를 나타냄 = 데이터의 변동성

→ 편차제곱합/자료의 개수

표준편차 : 분산의 제곱근, 단위가 보장됨

이산확률분포 : "베르누이"를 독립적으로 n번 반복하는 실험 결과, 결과가 확률값을 나타냄

이항분포 : 확률변수와 확률질량함수 정의 X~B[n,p]
포아송분포 : 단위 시간 안에 어떤 사건이 몇 번 발생할 것인지를 표현하는 이산 확률 분포

f(x)는 포아송분포의 확률질량함수

연속확률분포 : 구간을 적분해 확률값을 구함

지수분포 : 사건이 독립적일 때, 일정 시간동안 발생하는 사건의 횟수가 포아송분포를 따른다면, 다음 사건이 일어날 때까지 대기 시간을 표현하는 연속확률분포
f(x)는 지수분포의 확률밀도함수
정규분포 : 확률변수를 기술하는 가장 중요한 확률분포
→ Bell Curve라고 불리며, 종모양의 곡선으로 표현
→ 중심극한정리에 의해 자료의 분포를 근사하기 위해 자주 사용
t - 분포
→ 정규분포와 유사하게 좌우 대칭의 종모양으로 중심은 0
→ 정규분포는 표본의 수가 적으면 신뢰도가 낮아짐(n<=30)
→ t-분포는 자유도에 따라 그래프의 형태가 달라짐
· 표본의 수가 충분히 크면 표준정규분포와 거의 같과 적으면 꼬리가 두꺼워짐

정규분포와 표준정규분포의 차이는?

표준정규분포 : 평균이 0이고 분산, 편차가 1인 정규분포

→ 보통 Z분포(Noramalization = Standardization = Scaling)라고 표기 || Z~N(0,1)

- 큰수를 작은 수로 바꾸기 위해

- 단위통일(원래 값이 더 작은 값으로 바꾸며 더 쉽게 비교)

tkinter

유정임 — Tue, 29 Jul 2025 17:18:06 +0900

from tkinter import *

pack() : 위에서 아래서 sequential하게 하나씩 배치

grid() : 격자 무늬로 행과 열에 번호에 따라 배치

wnd = Tk() # 객체 생성
wnd.wm_geometry("500x400")
wnd.title("First GUI Test")
wnd.mainloop()

label1 = Label(wnd, text = "hello world")
label2 = Label(wnd, text = "안녕하세요")
label3 = Label(wnd, text = "반갑습니다")
label1.pack()
label2.pack()
label3.pack()

label1 = Label(wnd, text = "hello world")
label2 = Label(wnd, text = "안녕하세요")
label3 = Label(wnd, text = "반갑습니다")
label1.pack()
label2.pack()
label3.pack()

btn1 = Button(wnd, text = "First Button")
btn1.pack()

def btn_click():
    label3.config(text = "버튼이 클릭 됨")
    label3.config(font=('궁서체',28))
    label3.config(fg="red") #fg : 글자, bg : 배경

btn1 = Button(wnd, text = "First Button", command = btn_click)
btn1.pack()

# STEP1 : pack()의 옵션을 좀 더 알아보기
label1 = Label(wnd, text="label1")
label1.pack() #위에서 순서대로 배치

#label.config()대신에 위젯 생성 시, font, color, size등을 설정
label2 = Label(wnd, text="label2", fg="blue", bg="yellow", \
               width=20, height=2, font=('맑은고딕', 16, "bold"))
label2.pack()

#STEP2 : pack()의 side option
#pack()의 옵션사용해서 배치방향 설정
label3 = Label(wnd, text="label3", bg="blue")
label3.pack(side="left")

label4 = Label(wnd, text="label4", bg="red")
label4.pack(side="left")

label5 = Label(wnd, text="label5", bg="yellow")
label5.pack(side="left")

#STEP3 : pack()의 padding option
#pack()의 옵션을 사용해서 padding 설정 & side = [left, right, top, bottom] 효과보기
label3 = Label(wnd, text="label3", bg="blue")
label3.pack(side="left", padx=5, pady=5)

label4 = Label(wnd, text="label4", bg="red")
label4.pack(side="top", padx=5, pady=5)

label5 = Label(wnd, text="label5", bg="yellow")
label5.pack(side="bottom", padx=5, pady=5)

#STEP4 : place() 사용하기
#place()를 사용해서 배치(원하는 위치에 지정하는 방법)
x = 0
y = 0
label3 = Label(wnd, text="label3", bg="blue")
label3.place(x=x, y=x)

label4 = Label(wnd, text="label4", bg="red")
label4.place(x=x+100, y=y+100)

label5 = Label(wnd, text="label5", bg="yellow")
label5.place(x=x+200, y=y+200)

#Step 5 : grid()를 사용하요 배치
#grid()를 사용해서 행,열 index를 이용해서 배치하기(다른 배치방법과 혼용해서 사용할 수 없습니다.)
#위에서 label1.pack(), label.pack()을 주석처리해서 사용을 중지합니다.
label3 = Label(wnd, text="label3", bg="blue")
label3.grid(column=0, row=0)

label4 = Label(wnd, text="label4", bg="red")
label4.grid(column=1, row=1)

label5 = Label(wnd, text="label5", bg="yellow")
label5.grid(column=0, row=2)

파이썬 모듈, 패키지

유정임 — Thu, 17 Jul 2025 17:37:49 +0900

function이 모이면 module, module이 모이면 패키지

→ 이 모든 걸 합쳐서 라이브러리라고 부름

패키지 = 모듈이 제공하는 형태

Tuple, Set, Dictionary 정리

유정임 — Thu, 17 Jul 2025 11:57:03 +0900

Tuple

() 로 표현
튜플 생성시 ()와 ,(콤마) 사용
tu1 = 1, 2, 3 or tu1 = (1, 2, 3)
tu2 = 1, of tu2 = (1, )
※ 요소가 하나인 튜플을 만들 때 콤마를 사용하지 않으면 일반 값으로 인식
변경 불가능한 자료형이다.
사용 가능 함수 : len(), max(), min(), index(), count()
tuple()함수 이용해 공백 튜플 생성 혹은 리스트를 tuple로 변경 가능
tu3 = tuple() of tu3 = () → 공백 튜플 생성

Set

중복을 허용하지 않고 순서가 없음 → 인덱싱 불가
중복을 허용하지 않기 때문에 중복값을 제거할 때 사용
인덱싱이 필요하면 인덱싱 가능한 다른 자료형으로 변환해야 함
set 생성
s1 = set(s1) → s1을 set형으로 변경
s1 = set() → 공백 set 생성
{}로 표현
s1={}는 공백 set 생성이 아닌 공백 딕셔너리 생성
사용 가능 연산자 : | (합집합), &(교집합), -(차집합)
사용 가능 함수 : len(), max(), min(), union(합집합), intersection(교집합), difference(차집합)
합집합
- print(a.union(b)) = print( a|b )
교집합
- print(a.intersection(b)) = print( a&b)
차집합
- print(a.difference(b)) = print( a-b)
s1.add(원소) : 원소 추가
s1.remove(원소) : 해당 원소 제거(단, 해당 원소 없으면 에러)
s1.discard(원소) : 해당 원소 제거(해당 원소 없어도 에러 없음)
s1.clear() : 집합의 모든 원소 제거 → 공백집합(set())로 만들어줌

Dictionary

{}로 표현
key : value 쌍으로 이루어짐
key에 리스트 사용 불가, value에는 모든 자료형 가능

딕셔너리 생성

dic1 = {"나이" : 30} → 생성과 동시에 항목 추가
dic2 = {} or dic2 = dic() → 모두 공백 딕셔너리 생성

딕셔너리 항목 추가

dic2["나이"] = 30 → key(나이)를 인덱스 위치에 value(30)값을 대입연산자 오른쪽에 작성
dic2 = {"이름" : "홍길동", "이름" : "임꺽정"}
print(dic2) → 결과 : {"이름" : "임꺽정"}
※생성과 동시에 항목 추가 시 동일한 킷값을 갖는 경우 : 중복 저장 되지 않고 하나만 남음
dic3 = {}
dic3["이름"] = "홍길동"
dic3["이름"] = "임꺽정"
print(dic3) → 이름이 key인 value값은 임꺽정
※ key가 동일하면 중복 저장 되지 않으므로 value값 변경(덮어쓰기)

딕셔너리 삭제

del dic[] → [ ] 안에는 삭제할 key 들어감
del dic1["이름"] or del(dic1["이름"]) : key가 "이름"인 항목 삭제(value값도 함께 삭제)
※ 해당 key가 없는 경우 오류 발생
dic.pop(key) : key에 해당하는 항목(key-value 쌍)을 삭제 및 반환
※ 해당 key가 없는 경우 오류 발생
dic.clear() : key와 value 모두 삭제(전체 삭제)

딕셔너리 key, value 추출

dic.keys() → key값들만 추출, 인덱싱 사용 불가
dic.values() → value값들만 추출, 인덱싱 사용 불가
dic.items() → key와 value의 쌍을 튜플로 변환, 반복문에서 튜플로 받은 경우 인덱싱 사용 가능
※ 리스트처럼 보이지만 실제 리스트가 아님(시퀀스 형태이기 때문에 반복문에서 사용 가능)
리스트가 아니기 때문에 리스트 관련 함수 사용 불가(append, insert, count etc)
→ 리스트 관련 함수 사용하기 위해선 리스트로 변환 필요
get 함수
dic.get(key) → key에 해당하는 value 반환, 해당 key없으면 None 반환
print(dic1["나이"]) → "나이" key 없으면 에러
print(dic1.get("나이")) → "나이" key 없어도 에러 나지 않음
dic.get(key, default_value) → 해당 key 없으면 default_value 반환

출력(print) 형태, 문자열(string) 정리

유정임 — Thu, 17 Jul 2025 11:32:32 +0900

출력 형태 정리

print(a) : a를 출력
print(a,b) : a와 b 출력 (이때 a와 b 사이에 ,(콤마)는 출력 X)
print("apple", "banana") → 결과 : apple banana
print(a+b) : a와 b가 숫자일 경우 두 수의 합을 출력 / 문자열일 경우 문자열을 붙여서 사용ㄹ
print(3+5) → 결과 : 8
print("3"+"5") → 결과 : 35
print("apple"+"banana") → 결과 : applebanana
Q : 그럼 print(a+b)와 print(a,b)의 출력 결과는 같나?
A : 아니오. + 와 , 의 차이는 두 변수 사이에 공백을 함께 출력하느냐 마느냐의 차이
format 함수
name = "홍길동" 일때
- print(f"이름 : {name}") → 결과 : 이름 : 홍길동
- print("이름 : {}".format(name)) → 결과 : 이름 : 홍길동
% 사용
print("이름 : %s, 나이 : %d"%("홍길동',30)
→ 결과 : 이름 : 홍길동, 나이 : 30
- %d는 정수, %f는 실수, %s는 문자열
round 함수
round(변수,n) → 소수점 2째자리까지 표시 = 소수점 3째자리에서 반올림
round(3.7452,2) → 결과 : 3.75
※ n이 0일때는 .0 까지 같이 출력 ex ) round(3,0) → 결과 : 3.0
%f 사용
%와 f 사이에 .(점)과 숫자를 넣어 사용
- print("%.2f"%(3.7452)) → 결과 : 3.75 (반올림 되서 2째자리까지만 출력)
Q : print("%.2f"%(3.7452)) 랑 print(round(3.7452,2)) 는 같은 값을 출력하면 같은 것인가?
A : 아니오 앞에 "%.2f"는 문자열을 변환시킨것, 뒤에 round는 숫자 자체를 반올림해서 실제 계산에 바로 활용 가능
실수값에서 소수점 없이 출력 할 때
1. %.0f
2. int() → 대신 반올림은 안됨

문자열 표기 방법

: ' ', " ", ''' ''', """ """
→ 따옴표 3개는 여러 라인을 하나의 문자열로 처리할 때 사용 가능

\n : 줄바꿈 문자
\' : 작은 따옴표
\" 큰 따옴표

연산자 사용

+ : 피연산자가 모두 문자열이면 문자열 연결(복합) 연산자로 사용
* : 문자열*n이면, n만큼 문자열 반복

인덱싱과 슬라이싱

인덱스 : 항상 0부터 시작, len(문자열)-1]은 마지막 , 뒤에서부터는 -1로 시작

변수[start:end] → start ~ end-1 까지의 문자열 추출
변수[:end] → 0(처음)부터 ~ end - 1 까지의 문자열 추출 : 앞에 start가 생략되면 = 처음부터(인덱스 0부터)
변수[start:] → start ~ 문자열 끝까지 추출 : 뒤에 end가 생략되면 = 끝까지( 인덱스[len(변수)- 1]까지
변수[:] → start, end 모두 생략시 , 문자열 전체를 추출Q : 인덱싱과 슬라이싱 차이는?
A : 인덱싱은 문자 하나 추출, 슬라이싱은 문자 하나 이상 추출

문자 변경

- 문자열을 할당하면 해당 문자열은 문자열 상수이므로 문자열에 있는 문자 일부 변경 불가능

문자 일부만 변경 하는 법은

문자열 → 리스트로 변경 → 리스트 부분 변경 → 문자열로 변경
슬라이싱 조합을 통해 새로운 문자열을 생성

비트 연산자(시프트)

유정임 — Tue, 15 Jul 2025 10:35:00 +0900

1. 좌측 시프트(<<)

- 비트를 왼쪽으로 이동

<< 모양이 ← 화살표 모양이랑 동일하니 이해하기 쉽게

: 숫자를 왼쪽으로 밀어버리고 맨 뒤에 새로 생긴 칸에는 0 넣으면 됨

-2의 n제곱 곱하기

x = 5			# x를 이진수로 표현하면 0101
y = x << 1		# x 비트를 왼쪽으로 한칸 이동 후 y에 저장 = 이진수를 표현된 x를 왼쪽으로 한 칸 밂
				# 0101을 한 칸 밀면 => 1010이 됨
print(y)		# y는 1010이므로 십진수로 표현하면 결과 : 10

2. 우측 시프트(>>)

- 비트를 오른쪽으로 이동

>> 모양이 → 모양이랑 동일하니

: 숫자를 오른쪽으로 밀어버리고 맨 앞에 새로 생긴 칸에는 0 넣음(사실상 생략 가능)

※ 좌측 시프트와 다르게 맨 뒤 비트가 1인 상태로 뒤로 밀어버리면 소수점으로 넘어가는데 소수점은 버림

- 2의 n제곱으로 나누기

x = 20			# x를 이진수로 표현하면 10100
y = x >> 2		# x를 오른쪽으로 2칸 밀어버린 값을 y에 저장	
				# 10100을 두칸 밀어버린 결과인 00101를 y에 저장
print(y)		# 00101를 10진수로 변환하면 결과 : 5

머신 러닝

유정임 — Fri, 11 Jul 2025 11:00:17 +0900

ML(Machine Learinig)

; AI 구현기술 → 머신 러닝

머신러닝
├─ 딥러닝
│ ├─ RNN → 언어 모델 → 시계열 분석
│ └─ CNN → 컴퓨터 비전 → 이미지/비디오

딥러닝 ; 머신러닝의 한 분야
RNN ; 순환 신경망, 시계열 데이터나 순서가 있는 데이터 처리
언어 모델 ; 문장이나 단어의 확률 분포를 예측(GPT)
시계열 분석 ; 시간의 흐름에 따라 변화는 데이터 분석
CNN ; 합성곱 신경망, 이미지 처리에 강함
컴퓨터 비전 ; 영상이나 이미지에서 의미 있는 정보 추출(객체 인식, 얼굴 인식)
이미지/ 비디오 : 데이터

프롬프트 엔지니어링

; 대화형 인공지능을 최적의 방법으로 다루는 기술

→ 좋은 답변을 생성하도록 도와줌

- 답변의 품질(Quality)

- 일관성(Consistency)

- 관련성(Relevance)

- 편향성(Bias)

문자열 변환

유정임 — Thu, 10 Jul 2025 15:16:57 +0900

문자열 ▶ 대문자

; 문자열을 대문자로 변환하려면 upper() 이용

str = "hello"
print(str.upper())

#결과 HELLO

문자열 ▶ 소문자

; 문자열을 소문자로 변환하려면 lower() 이용

str = "HELLO"
print(str.lower())

#결과 hello

문자열 ▶ 첫글자만 대문자 나머지는 소문자

; 첫글자만 대문자로 만들고 나머지는 소문자로 만드려면 capitalize() 이용

str = "hELLO"
print(str.capitalize())

#결과 Hello

Q : 대문자로 입력받은 문자열을 소문자로, 소문자를 대문자로 출력하려면?

#문자열 입력받아 리스트에 삽입
str = list(input())

#l은 리스트의 길이
l=len(str)

#0부터 l-1값까지 반복
for i in range(l):
    if str[i] < 'a' :
        str[i] = str[i].lower() #대문자를 소문자로
    else :
        str[i] = str[i].upper() #소문자를 대문자로
        
print(''.join(str))

위에 lower와 upper만 사용해도 충분히 구할 수 있지만 더 간단하게 코드 짤 수 있는 방법이 있다

▶swapcase() 이용

; 소문자를 대문자로 대문자를 소문자로 바꿔준다. 즉, 서로 바꿔줌

str=input()
str=str.swapcase()
print(str)

HTTP와 프로토콜 등 네트워크 정리

유정임 — Thu, 10 Jul 2025 09:47:45 +0900

HTTP란?

; 인터넷상에서 데이터를 주고 받기 위한 서버/ 클라이언트 모델을 따르는 프로토콜

HTTP의 메소드

; request하는 방식 정의

GET : 주어진 URL에서 자원 요청
POST : 주어진 URL로 자원의 생성 요청
PUT : 주어진 URL로 자원의 대체 요청
DELETE : 주어진 URL로 자원의 삭제 요청
HEAD : 주어진 URL에서 자원의 헤더만을 요청,
해당 자원이 존재하는지 혹은 서버에 문제가 없는지를 확인하기 위해 사용
OPTIONS : 주어진 URL에서 처리 가능한 메소듸 목록 요청

HTTP 요청, 응답

HTTP Client가 요청 보낼 때 가능한 경우 2가지 : GET request, POST request

HTTP Server가 응답 돌려줄때 지켜야 하는 규약 : 2xx, 3xx etc

100번대 : 정보 응답 → 클라이언트가 요청을 계속 진행해도 된다는 중간 메세지
200번대 : 성공
300번대 : 리다이렉션 → 요청한 자원이 다른 곳에 있음
400번대 : Not found → 서버는 살아 있지만 요청의 문제
500번대 : 서버 오류
- 서버 내부 문제 : 서버의 설정, 코드, 응용 프로그램 등의 오류
- 네트워크 문제 : 클라이언트와 서버 사이의 중간 서버가 통신 오류 일으킴

스위치는 L2 장비(Physical + MAC)

→ 그저 물리적 장비들 묶어놓은것

라우터는 L3장비(Physical + MAC +Network)

→ network 포함 되어 있어서 IP 주소 해석 가능

∴ 스위치는 라우터랑 함께 있어야 함

LAN + LAN + · · · + LAN → WAN

bandwith : 대역폭 throughput : 얼마나 빨리 처음부터 끝까지 도달하느냐

라우터

; 라우터는 네트워크와 네트워크 사이를 연결

= 데이터가 어디로 가야 할지 길을 안내해주는 네트워크의 네비게이션

역할

패킷 전달(Routing)
→ 데이터가 목적지에 도달할 수 있도록 최적의 경로 찾음
네트워크 연결
IP 주소 관리 및 NAT 기능
→ 내부 IP 를 외부 IP로 바꿔주는 NAT(Network Address Translation) 기능

라우터 프로토콜

목적

- 네트워크 상의 경로 설정

- 변화된 네트워크 환경에 빠르게 적응

- 다른 라우터들과 정보 공유를 통해 전체 네트워크 상태 파악

종류

거리 벡터 라우팅 프로토콜
- 기본 원리 : 목적지까지의 거리(홉 수)와 방향(다음 라우터)에 대한 정보 기반으로 경로 결정
- 정보 전파 : 일정 시간마다 전체 라우팅 테이블을 이웃 라우터에 전송
- 장점 ; 구현 단순 / 단점 ; 속도 느림
예 ) RIP ; 최대 15홉
링크 상태 라우팅 프로토콜
- 기본 원리 : 모든 라우터가 전체 네트워크 토폴리지를 파악 후, 최적 경로 계산
- 정보 전파 : 변경사항이 있을 때만 상태 정보를 주변에 전달
- 장점 ; 빠른 속도, 정확성 / 단점 ; 구현 복잡
예 ) OSPF ; Dijkstra 알고리즘을 사용해 최단 경로 계산

내부 vs 외부

- IGP : 하나의 자율 시스템 내부에서 사용

대표 ) RIP, OSPF

- EGP : 여러 자율 시스템 간 라우팅에 사용

대표 ) BGP

ICMP(Inernet Contro Message Protocol)

;TCP/IP가 구현된 컴퓨터 및 네트워크 기기 사이에서 통신 상태를 확인할 때 이용하는 프로토콜

- OSI 3계층(네트워크 계층)에서 동작

- 계층은 IP와 동일, 하지만 IP 위에서 동작

- ICMP는 TCP나 UDP를 사용하지 않고 단독으로 움직임. 사실당 TCP와 UDP와 동일한 위치(전송 계층)에 있음

- 포트 번호는 존재 X

RTT(Round Trip Time)

; 우리가 핑 보냈을 때 다시 돌아올 때까지 걸리는 시간

URL

http:// 93.156.127.12 :80 /news /index.html

프로토콜 주소 포트번호 디렉터리 이름 파일 이름

클라이언트, 서비스, 리졸버, DNS 서버의 관계

7. 파일 접근 권한 관리와 프로세스 관리

유정임 — Wed, 9 Jul 2025 12:21:47 +0900

파일의 속성을 보는 명령어 : ls -l

파일 접근 권한 종류

r-x -w- wx : 3개씩 3묶음

- 앞에서 세개씩 사용자, 그룹, 기타 권한(사용자도 아니고 사용자도 속한 그룹도 아닌 소유자)

- r은 읽기 권한, w는 쓰기 권한, x는 실행 권한으로 표기

첫번째 root : 소유자

두번째 root : 소유 그룹(파일이 속한 그룹)

2223 : 파일 크기(byte)

파일 접근 권한을 변경하고 싶다면 ?

→ chmod

※ 기호 모드와 숫자 모드 두 가지로 이용 가능

r - x 로 바꾸고 싶다면 → 1 0 1 → 1*4 + 0*2 + 1*1 = 5

→ chmod 542 text.txt = 사용자에 읽기와 실행권한 , 그룹에 읽기권한, 기타에 쓰기 권한 제공

Q :리눅스 셸에서 !로 시작하는 명령어는 ??

A : !l, !e, !v 등등 !로 시작하는 명령어는 명령어 앞 글자를 기준으로 이전에 쳤던 명령어를 재실행하는 명령어

→ !e = 마지막으로 e로 시작한 명령어 실행

프로세스

; 현재 시스템에서 실행 중인 프로그램

- 리눅스는 다중 프로세스 시스템 = 동시에 여러 프로세스 실행

- 작성한 프로그램은 실행 전까지는 디스크에 저장된 정적인 파일

→ 파일 실행시 OS가 코드, 데이터, 스택, 힙 등 메모리 공간을 할당하고 이를 OS 안에서 하나의 프로세스로 실체화(구현)

→ CPU가 실행할 수 있도록 PCB도 만들어 관리

명령어 ps

; 현재 실행 중인 프로세스에 대한 정보를 출력

- 단독으로 사용 불가능하고 옵션을 꼭 붙여줘야 함

ps -ef : 시스템에서 실행 중인 모든 프로세스의 정보 + 자세한 정보를 출력
ps -aux : 터미널에서 실행시킨 프로세스의 정보 + 프로세스 소유자 이름, CPU사용량, 메모리 사용량 등 상세 정보 + 시스템에서 실행중인 모든 프로세스의 정보를 출력

명령어 kill

; 지정한 시그널을 프로세스에게 보낸다.

kill -2 PID : 인트럽트 시그널을 보낸다.
kill -9 PID : 프로세스를 강제로 종료
kill -15 PID : 프로세스와 관련된 파일들을 정리하고 종료, 종료되지 않은 프로세스가 있을 수 있다.

명령어 nohup

; 로그아웃한 후에도 백그라우드 작업을 계속 실행 = 특정 프로세스를 백그라운드로 전향시킬 수 있는 명령어

- 백그라운드 작업을 실행한 터미널이 종료되거나 사용자가 로그아웃하면 실행 중이던 백그라운 작업도 함께 종료

- 로그아웃한 다음에도 작업이 완료될 때까지 백그라운드 작업을 실행할 경우

URL 의 구성

http:// (프로토콜)

+ naver.com(도메인 이름)

+ :80(port number [기본이 80])

+ querystring

→ 쿼리 스트링에는 path + resource name이 포함되어 있음

각각의 IP주소가 다른 이유

○ 사설 IP

; 공유기 / VM 등 로컬 네트워크에서만 쓰이는 IP

○ 공인 IP

; 인터넷에 실제로 노출되는 IP

- 여러 내부 IP들이 하나의 공인 IP를 통해 인터넷 연결 → NAT(주소 변환) 때문

ifconfig = VM 리눅스 안의 사설 IP
ipconfig = 윈도우 호스트의 사설 IP
네이버 "내 IP" = 공인 IP (공유기가 가진 주소)

6. shell

유정임 — Wed, 9 Jul 2025 11:07:31 +0900

메모리의 종류

- disk

- RAM (Read Access Memory) - write o, read o

- ROM (Read Only Memory) - write x, read o

메모리 구조

static

- 프로그램과 수명을 같이 함 → 수명 : 프로세스 전체 생애 주기

- 한 번 할당되면 끝까지 유지

heap

- 스택영역에 쌓인 나머지 공간

- 한 번 만들어놓은 메모리를 직접적으로 죽이지 않는 이상 계속 존재

- 죽이지 않은 이상 static 영역처럼 존재

- 수명이 프로그래머에게 달림

stack

- 휘발성 메모리

- 자동으로 사용하지 않으면 소멸

code segment

- 프로그램 코드 자체가 저장되는 영역

kernel

- 운영체제의 핵심 부분, 컴퓨터 하드웨어 직접 제어

- 사용자나 응용프로그램과 직접 대화 불가

- 커널은 시스템 자원 관리, 프로그램이 요청하는 작업 수행하는 중재

shell

- 사용자와 커널 사이의 인터페이스

- 사용자가 입력한 명령어를 해석해서 커널에게 전달, 결과를 다시 사용자에게 표시

- 예) bash, zsh, sh

linux

- 커널을 중심으로 구성된 운영체제 전체를 가리킴

- 리눅스 = 리눅스 커넬 + 셸 + 기타 도구

shell 의 기능

- 명령어 해석기

- 사용자 환경 설정 기능

- bash : 리눅스의 기본 쉘

- 특수문자 >, >>

○ > : 앞쪽의 실행 결과를 뒤의 파일에 저장

○ >> : 앞의 실행 결과를 뒤의 파일 의 끝부분에 추가

쉘에서 커널로 요청 보내면 과정을 처리하는 과정 : blocked process

blocked process가 밖에 스레드와 연결 되서 처리 되는 과정

: nonblocked process

= 커널이나 시스템 자원을 요청했을 때, 그 결과가 즉시 반환하는 경우

= 작업이 완료되지 않아도 프로세스가 멈추지 않고 계속 실행 가능 한 프로세스

시스템 환경 설정 파일

사용자 환경 설정 파일

쉘 스크립트

: OS 이용하기 위한 명령어

- 쉘에 대한 명령을 미리 텍스트 파일에 저장한 것이다. 여러 명령을 조합한 일련의 조각을 모아서 실행 가능

권한 설정

쉘 스크립트로 이용할 수 있게 실행 권한 부여해야 함 → chmod 이용

쉘 스크립트 작성법

- 파일명.sh 형태로 암묵적으로 정함 (확장자는 아님)

#!/bin/sh

→ 쉘의 종별 선언 : 쉘 스크립트는 쉘에 따라 만드는 방법이나 사용할 수 있는 기능이 다름 + 어느 쉘용인지 표시

+ 첫째줄에 무조건 선언

#! = 이건 쉘 스크립트다

/bin/sh = 해당 경로에 가면 dash쉘(default 쉘)이 있다

5. vi 에디터

유정임 — Tue, 8 Jul 2025 16:57:24 +0900

vi 파일명 : 이미 기존에 있는 파일이 있다면 해당 파일로 진입, 없다면 새로 생성

명령모드 → 입력 모드

i : insert

a : append

입력 모드 → 명령 모드

Esc = > 대부분 저장하기 위해 명령 모드로 돌아옴

명령 모드 → (vi내에서) 마지막 행 모드

: 랑 / 랑 ? 누르면 이동

마지막 행 모드에서

- w ; 저장만 함 , 종료는 x

- :wq ; 저장하고 종료, 오류 있을 시 알려줌

- :wq! ; 저장하고 강제 종료, 오류 있어도 종료

- q ; 종료, 오류 있을 시 알려줌

- q! ; 강제 종료

Q : insert 모드에서 문자를 지우려면?

A : 현재 입력 모드이기 때문에 Esc 키 눌러서 명령 모드로 이동한 뒤 'x'눌러서 한 글자씩 삭제

+ 한 줄씩 삭제 하려면 원하는 행에 커서 놓고 'dd'

Q : 한 줄 모두 복사하려면 ?

A : 'yy' 누르면 copy → 붙여놓기 하고 싶은 곳에 커서 놓고 'pp' 누르면 paste

Q : 에디터가 너무 길어져서 숫자가 필요하면?

A : :set number라고 치면 행번호 나타남

Q : 한 줄의 글이 너무 길어서 바로 맨 뒤로 가서 입력하고 싶다면?

A : Shift + A 누르면 바로 이동해서 append 모드

Q : 여러 줄을 복사하고 싶다면?

A : 명령어 모드에서 숫자 + y 누르고 이동해서 p누르면 됨

4. Linux

유정임 — Tue, 8 Jul 2025 10:59:40 +0900

유닉스와 리눅스

Unix : 리눅스 이전의 OS가 명령어 버전

Linux : 유닉스와의 호환성 및 공개 소프트웨어, 유닉스 경량화

리눅스 커널 : 우리가 일반적으로 말하는 OS

- 앱의 명령을 OS 내부 커널에 전달, 처리 후 하드웨어로 전달

- 앱 ↔ OS(커널) ↔ 하드웨어 흐름

- 리눅스는 운영체제를 뜯을 수 있다. 이때 운영체제를 커널로 부른다.

- OS는 앱과 하드웨어 사이를 이어주는 중재자

- 자원 관리, 프로세스 관리, 파일 시스템 관리

커널

- 운영체제의 핵심 부분

- 하드웨어와 밀접하게 상호작용, 사용자 프로그램은 커널 통해 간접적으로 하드웨어 접근

- 앱의 명령 받음 → 하드웨어에서 실행 → 결과 앱에 전달

- 프로세스 스케줄링, 메모리 관리, 디바이스 제어, 시스템 콜 처리

- 커널도 결구 OS의 일부, OS의 핵심 구성 요소

쉘

- 커널을 핸드링 하기 위한 명령어 집합

- 사용자가 명령어를 입력해서 커널과 상호작용할 수 있도록 함

리눅스는 운영체제 전체 의미, 정확히는 리눅스 커널
오픈소스로 자유롭게 수정, 재배포 가능

명령어 정리

- sudo : root로 명령어 실행

adminstratior : 모든 권한을 가진 사용자

- 윈도우에서 쓰는 말로 리눅스의 root와 같은 말

root 계정

- 최상위 관리자 = 슈퍼 유저

사용자 계정

- 제한된 권한

- 시스템 파일 일부만 가능

- ifconfig : 네트워크 인터페이스의 상태를 확인하고 설정

inet 6 : 6바이트로 구성된 주소체계

inet : 4바이트로 구성된 주소체계

inet이 고갈될 줄 알고 미리 만들어놓은 inet6

- ls (+옵션): list 줄임말로 하위 폴더 보여줌

- a : 숨겨진 모든 파일 보여줌

- l : 파일들의 상세 정보

- d : 디렉터리 자체 정보 출력

- i : 첫번째 행의 inode 번호 출력

- A : ' . '와 ' .. '를 제외한 모든 파일 목록을 출력

- man 명령 : 뒤에 나오는 명령어에 대한 사용 방법

ex ) man ls : ls에 대한 설명 나옴

- date, clear : 현재 시간, 정리

- passwd : 비밀번호 변경

- pwd : 현재 내가 위치한 경로

- mkdir : 디렉터리 생성

- rmdir : 디렉터리 삭제

- rm : 파일 삭제

rm -rf : 파일 안에 존재 유무 상관없이 무조건 지움

그냥 rm만 사용하면 디렉터리를 지울 수 없음

- cat : 파일 내용 출력

- cp : 파일이나 디렉터리 복사

cp -r : 디렉터리 복사시에는 -r이 붙어야함

cp 옵션 파일1 파일 2 : 파일 1을 파일 2에 복사

-i : 파일 2가 이미 존재한다면 덮어쓸 것인지 물어본다

- mv : 파일 또는 디렉터리 이동

mv -i 파일1 파일 2 : 파일 2가 존재하면 덮어쓸 것인지 물어봄

- ps : 프로세스 보여줌

ps -ef 모든 프로세스 보여줌

grep 조건 파일 : 필터링 된 파일들 보여줌

ex ) ps -ef | grep "bash" == ▶ps -ef 하면 모든 프로세스 보여주는데 bash라고 되어있는 텍스트 라인만 추출 가능

ex ) grep -l "de" *.c == 확장자가 .c인 모든 파일에서 "de"가 포함된 파일명을 출력한다.

디렉터리와 파일 사용법

심볼릭 링크 : 바로가기

bin : execution 파일 포함해서 기본 명령어 실행파일 저장
etc : 설정 파일 저장(환경 설정, 설정 스크립트), 네트워크와 관련된 설정 파일
usr : 사용자용 프로그램과 라이브러리 등장
home : 일반 사용자들의 개인 폴더가 있는 장소
lib : 공통 라이브러리 파일 저장
home 디렉터리 아래에 tmp라는 디렉토리를 만들면?? home - 사용자(yujung) - tmp 로 만들어짐

절대경로와 상대경로

1. 절대 경로

- 반드시 ' / '로 시작(' / ' = 최상단 위치 = root )

- 목표까지 중간에 있는 모든 디렉터리의 이름을 표시

- 현재 어디있든 특정 위치를 가리키는 경로는 항상 동일

2. 상대 경로

- ' / '제외한 문자로 시작

- 현재 위치 기준으로 상위를 가려면 '..'로 시작

ex) cd ./../lib → ' . '는 현재 폴더를 나타냄 : 현재 폴더의 상위 폴더를 가서 하위 디렉터리인 lib로 이동

홈 디렉터리로 바로 이동 : cd ~ or cd

파일 생성하는 방법

'abc' > a.out → command 오류

해결 방법 : echo 'abc' > a.out

파일 생성 방법은 echo "문자열" > 파일명

echo "문자열" 하면 바로 문자열이 출력 된다.

보고 의미 해석해보기

3. simple network

유정임 — Mon, 7 Jul 2025 09:21:49 +0900

dest/src/dest port/src port + 형태 → 이 다섯가지가 있어야 통신을 할 수 있음

End - to - End 통신 절차

- TCP 헤더에 붙을 지 UDP 헤더에 붙을 지 결정하는 건 데이터의 특성에 따라 달라진다. .

- UDP는 비연결형, 오류 복구를 하지 않음, 신뢰성이나 순서 보장은 하지 않음. 대신 오버헤드가 적음 => 속도 빠름

보내는 데에 의의를 둠(택배) → 게임에 많이 이용 : 속도가 빨라야 해서

- TCP는 책임을 지는 스타일(등기우편)

- UDP는 Reciever크기도 상관 없이 무작정으로 보내고,

- TCP는 send한걸 Reciever에서 응답한 후 다시 전송(순차적) + 크기 고려함(Flow Control)

- 소켓 : 프로그램에서 통신을 구현할 때 사용하는 API, TCP 소켓, UDP 소켓 중 선택

- 소켓은 UDP와 TCP 중에 뭘 고를지 결정 + 응용 프로그램에서 OS의 네트워크 계층과 통신하기 위한 IFC

- IP header는 출발지 IP 주소(=src address)와 목적지 IP 주소(=dest address)를 붙여줌

- IP는 주소 체계와 라우팅을 담당

- IP(Internet Protocol)는 4바이트의 주소체계 가짐

- 깃발 꽂기 : 인터넷 프로토콜에서 최단 경로를 찾는 알고리즘 (shortest process) => 라우팅

- LAN(Local Area Network)

- 여러 LAN과 라우터, 중계 장치 묶어서 WAN(Wide Area Network)을 만듦

- LAN 구축 기술과 WAN 구축 기술은 다르다.

- IP 할당 안되면 통신 안 됨

- 포트 번호 : UDP/TCP에서 사용하는 주소로 하나의 IP에서 여러 애플리케이션 구분 가능

TCP header

UDP header

Transport Layer

- 송신 측에서 데이터를 어떤 방식으로 보낼지 udp와 tcp 중 선택

- 수신 측에서는 해당 프로토콜에 맞춰 데이터 복원

Internet Layer(Network Layer)

: 깃발뽑기에서 최단 경로 돌려줄게 + 어디로 가야 알아야 최단경로를 찾든 말든 ( IP address)

- 가장 빠르다기보다는 장애가 난 곳을 우회하는 path 확보 (= 네비게이터)

- 패킷(ip header + ip data)이 목적지까지 가능 경로를 계산(라우팅)하는 계층

- IP 주소를 통해 어디로 가야 최단 경로일지 결정

Link Layer : 실제 데이터를 물리적 네트워크로 전송하는 계층

- 데이터를 프레임으로 감싸고 0과 1의 전기 신호로 바꿔서 전송

- 프레임 단위 전송

- 네트워크 레이어에서 패킷이 링크 레이어에서는 프레임으로 불림

- 프레임 : 10진수로 내려온 데이터들을 진수를 바꿈

- 헤드 부분에 MAC Address가 붙음 → MAC 이용하면 속도가 빠름

- MAC 주소 기반 통신 → MAC 주소는 유일한 주소 (IP주소는 바뀔 수 있음)

- LAN안에서만 통신하기 위한 IP 기능

IP Addressing

- A~E로 다섯개로 클래스화 되어 있다

→ 적은 IP 주소의 갯수를 서브네팅을 하기 위해

→ 서브넷팅 하는 이유 : 더 많은 PC에 IP 할당

IP Addressing

- A : 0 + 7bit → Network Address, 나머지 24bit → Host Address

- B : 10 + 14bit → Network Address, 나머지 16bit → Host Address

- C : 110 + 21bit → Network Address, 나머지 8bit → Host Address

- A가 가장 큰 규모의 네트워크

멀티 캐스트와 브로드 캐스트의 차이

- 멀티캐스트는 특정 주소 이용해서 서비스 가입한 호스트들에게 데이터 전송

- 브로드캐스트는 네트워크에 연결된 모든 기기에게 데이터 전송

→ 뒤에 있는 host address가 모두 1로 채워지는 경우(255.255.255.255)

Subnet Mask

- 200.23.16.0/23 : 23비트는 네트워크 주소임을 알려줌

- 네트워크와 호스트 구분 위한 마스크

CIDR : 뒤에 네트워크 주소 넣어가지고

Q : 220.67.124.32/25 ??

11011100. 01000011. 01111100. 00100000

→ 앞에 25개가 네트워크 , 뒤에 7개가 호스트

서브넷은?? 네트워크를 1로 채우고 나머지 7bit를 0으로 채운다. (11111111 11111111 11111111 10000000)

- 0000000~1111111 까지 총 128 - 1개 만큼 호스트 붙일 수 있음.

- subnet 부분의 주소는 비트 그대로 표기

- 호스트 부분의 주소는 0으로 표기

- 비트로 표기된 주소를 10진수로 변환

- 변환된 주소 뒤에 / 이후 subneet 부분의 비트 수를 정수로 표기 (25 bits)

enumerate 정리

유정임 — Wed, 21 May 2025 00:00:44 +0900

enumerate 사용하는 경우

▶ 반복문 사용시 인덱스랑 값을 동시에 사용할 때

for index, value in enumerate(리스트):

→ index : 현재 반복중이 요소의 인덱스

→ value : 리스트 안의 값

따로 리스트[index]안해도 되서 편리

range(len(a)) 를 enumerate(a) 로 간편하게 사용 가능

백준 2804번 크로스워드 만들기

유정임 — Tue, 20 May 2025 23:22:02 +0900

문제 해석

→ A와 B는 30글자 내외에 문자로 주어진다.

A와 B에 같은 글자를 찾기 위해 중첩 반복문을 돌린다 해도 30*30으로 시간 복잡도가 O(900)으로 1초 이내 가능

코드 풀이 (아래 코드)

a와 b를 중첩 반복문으로 돌며 같은 글자가 있을 때 해당 인덱스 값을 각 m,n에 저장
리스트에 a의 길이와 b의 길이만큼 각 가로와 세로길이를 설정하고 '.'를 기본값으로 설정
1번에서 나온 m,n값으로 해당 행에는 a를 해당 열에는 b를 각각 입력해 넣는다.
출력

a, b = input().split()

for i in b:
    for j in a :
        if i==j :
            m=a.index(j)
            n=b.index(i)

lists=[["."for _ in range(len(a))] for _ in range(len(b))]
#lists[n]=a

for row in range(len(a)):
    lists[n][row] = a[row]
    
for row in range(len(b)):
    lists[row][m] = b[row]

for row in lists:
    print("".join(row))

회차별 수정 사항

1. m,n 값을 기준으로 a와 b를 넣을 때 lists[n] = a 를 넣었다

발생 문제점 => 후에 m,n 값을 이용해 b를 해당 열에 넣을 때 type error 오류 발생

이유 : lists[n] = a에서 문자열을 한번에 삽입했다. 문자열은 수정이 안되기 때문에 b를 열로 넣을 때

두 문자가 일치하는 부분에서 오류 발생

해결 : 반복문을 사용해 a값을 하나씩 삽입

2. 문제에서 중복되는 문자가 여러번 등장할 경우 a에서 제일 먼저 등장하는 경우, b에서 제일 먼저 등장하는 경우로

찾아야 하는데 위에 식에서는 b를 기준으로 a가 돌기 때문에 오류 + 가장 먼저 같은 부분을 찾았다 하더라도 반복문이

계속 돌기 때문에 결국 맨 뒤에있는 값을 반환함

해결 : enumerate로 변경하고 두 문자가 같을 경우 바로 인덱스 반환 동시에 반복문이 종료되게끔 변경

최종 코드

a, b = input().split()
for m,j in enumerate(a):
    if j in b:
        n = b.index(j)
        break


lists=[["."for _ in range(len(a))] for _ in range(len(b))]

for row in range(len(a)):
    lists[n][row] = a[row]

for col in range(len(b)):
    lists[col][m] = b[col]

for row in lists:
    print("".join(row))

백준 4592번 중복을 없애자

유정임 — Mon, 19 May 2025 20:54:15 +0900

문제 풀이

: 여러 숫자 중 연속해서 나오는 숫자는 한번만 출력

시간 복잡도

: 1초

정수 N(=코드에서 리스트 길이)가 최대 25이기 때문에 넉넉히 풀이 가능

코드 풀이

N과 N개의 숫자가 추가적으로 들어온다. => 입력값을 리스트에 저장
이때 N이 0이면 종료 => while문을 돌리다가 N이 0일 때 반복문이 종료되는 조건문 추가
N값과 바로 뒤에 나오는 수가 같을 경우 4번 조건문에 걸릴 경우를 대비해 미리 제거
리스트 처음부터 끝까지 두개씩 비교하여 만약 값이 같을 경우 둘 중에 하나를 0으로 저장
리스트에서 0이 아닌 값들만 출력

while True:
    # 1번 : N과 N개의 숫자를 리스트로 저장
    lists = list(map(int,input().split()))

    # 2번 : N이 0이면 반복문 종료
    if lists[0] == 0 :
        break
    #3번 : 맨 앞에 N값 제거한다.
    #N값은 리스트의 길이이기 때문에 제거함과 동시에 리스트 길이(l)로 저장
    l=lists.pop(0)

    #4번 : 두값씩 비교해 같은 경우 하나를 0으로 저장
    for i in range(l-1):
        if lists[i] == lists[i+1]:
            lists[i] = 0
    
    #5번 : 0이 아닌 값만 출력
    for i in range(l):
        if lists[i] != 0 :
            print(lists[i],end = " ")
    print("$")

백준 11866번 요세푸스 문제

유정임 — Sun, 26 Jan 2025 19:19:08 +0900

문제 해석

→ n : 총 인원 수, k : k번째 사람 제거

k 번째 사람을 제거하다가 n까지 도달하면 다시 1로 와서 진행

시간 복잡도

→ while 문으로 k번째 사람을 계속 제거하다가 n명 모두 제거되면 루프 종료하므로 O(n)

코드 풀이

n, k를 공백으로 나누어 정수형으로 저장
리스트를 1부터 n까지 수를 리스트 생성
제거한 사람들을 저장할 리스트 생성(=yo)
인덱스를 계산하고 인덱스에 해당하는 값을 circle_list에서 제거하고 그 값을 yo 리스트에 삽입
출력 형식 맞춰서 출력

n, k = map(int, input().split()) 
circle_list = list(range(1, n + 1))  
yo = [] 
index = 0  

while circle_list:  
    index = (index + k - 1) % len(circle_list)  
    yo.append(circle_list.pop(index))  

print("<" + ", ".join(map(str, yo)) + ">")

백준 2193번 이친수

유정임 — Fri, 24 Jan 2025 12:32:08 +0900

문제 해석

→n : n자리 이친수의 개수 구하기

문자열의 마지막 자리가 1이면 다음은 0만 가능하고, 마지막 자리가 0이면 0과 1 모두 가능하다.

시간 복잡도

→ n값에 따라 따라 반복문을 돌기 때문에 O(n)

코드 풀이

n을 정수로 입력받는다.
이친수의 갯수를 저장할 딕셔너리 생성 =binary_dic
n이 1과 2일때는 0과 1의 갯수가 각각 0개, 1개이다.
반복문은 n이 3이상일 때만 돌며 binary_dic[0]의 갯수는 이전 딕셔너리의 binary_dic[0]+binary_dic[1]이다. binary_dic[1]의 갯수는 이전 딕셔너리의 binary_dic[0]이다 ▷3번 참조
dictionary_dic[0]+dictionary_dic[1]의 값을 출력

n=int(input())
binary_dic={0:1,1:0}

for i in range(3,n+1):
    a = binary_dic[0]
    b = binary_dic[1]
    binary_dic[0] = a + b
    binary_dic[1] = a
    
print(binary_dic[0]+binary_dic[1])

백준 2303번 숫자 게임

유정임 — Fri, 24 Jan 2025 11:19:01 +0900

문제 해석

→ n : 게임 참가자 수

n명은 모두 5개의 숫자카드를 받는다. (5개의 숫자 카드는 1부터 10까지의 수로 중복 가능)

각자 5개 숫자 중 3개를 뽑아 더한 후 일의 자리 수를 구할 때 구할 수 있는 가장 큰 수를 가진다.

각자 가지고 있는 수 중에 값이 가장 큰 사람이 이기고 이 사람의 번호를 출력한다.

(두명 이상일 경우 번호가 큰 사람 번호 출력)

시간 복잡도

→ 최댓값을 찾거나 인덱스 찾는 부분은 O(n)이다.

→ 5개 중에 3개를 골라 더해야 하는 부분의 시간 복잡도는 O( ㎥ )이고 이 문제에서의 m은 5이기 때문에 즉, O(125)이다.

코드 해석

n을 입력받아 정수로 저장하고 카드 리스트를 저장할 공백의 카드 리스트 저장한다=card_list
반복문 n번을 돌며 입력받은 정수들을 공백으로 나누어 card라는 리스트에 저장한다.
card에 저장된 값들로 3개를 뽑아 더한 후 가장 큰 일의 자리수를 구한 후 card_list에 삽입
가능한 일의 자리수는 0~9이므로 기본 값을 0으로 설정후 3개를 뽑아 더한 후 10으로 나눴을 때 0으로 설정한 기본값보다 크면 더 큰 값을 반환하는 함수를 만든다.
card_list에서 가장 큰 수를 구한다.
5에서 나온 수를 가지고 있는 사람 중 가장 큰 번호의 소유자를 출력한다.

from itertools import combinations

n=int(input())
card_list = []

def max_num(cards):
    max_combi=0
    for value in combinations(cards, 3):
        v=sum(value)%10
        max_combi=max(v,max_combi)
    return max_combi



for i in range(n):
    card=list(map(int,input().split()))
    s=max_num(card)
    card_list.append(s)

num=max(card_list)
ans=0
for j in range(n) :
    if card_list[j] == num :
        ans=j

print(ans+1)

회차별 시도 사항

→ 마지막 for문을 돌리지 않은채 print(ans+1)을 하여 가장 큰 수를 가진 사람 중 첫번째 사람을 출력해서 for문 추가

백준 5567번 결혼식

유정임 — Wed, 22 Jan 2025 14:33:51 +0900

문제 해석

→ n: 상근이 동기의 수가 총 n명

→ m : 리스트의 길이 = 주어지는 관계의 수

→ a, b가 m번 주어짐 : 친구 관계가 m번 나타남

동기 중 상근이의 친구와, 친구의 친구까지 더한 수를 구한다.

시간 복잡도

→ dfs를 풀려다가 어차피 친구의 친구의 친구,,, 등 계속 관계하는 친구의 수를 구하는 것이 아니기에 set로 풀기로 함

그래서 총 시간복잡도는 O(n)

코드 풀이

n과 m을 입력받아 정수로 저장
친구들을 저장할 리스트 friends 생성
m번동안 a,b 친구 관계를 입력 받으면서 friends 리스트에 저장
상근이의 친구, 즉 1번의 친구는 무조건 초대받기 때문에 friends[1]을 초대친구목록(invite_friend)에 저장
invite_friend를 set()로 변경해서 중복 허용 불가
friends[1]에 있는 친구들의 친구들을 반복문을 이용해 invite_friend에 저장
상근이는 포함시키면 안되므로 invite_friend에 상근이가 있으면 삭제
▶무조건 invite_friend.remove(1)할 경우 1이 없다면 오류가 나므로 조건식으로 진행
set()함수의 길이가 곧 초대받은 친구들의 집합이기 때문에 길이 출력

import sys
n=int(sys.stdin.readline())
m=int(sys.stdin.readline())

friends=[[]for _ in range(n+1)]

for _ in range(1,m+1):
    a, b = map(int,sys.stdin.readline().split())
    friends[a].append(b)
    friends[b].append(a)

invite_friend=set(friends[1])
for i in friends[1]:
    invite_friend.update(friends[i])

if 1 in invite_friend:
    invite_friend.remove(1)
print(len(invite_friend))

회차별 시도 사항

→ 런타임 에러 : invite_friends.add(friends[1])로 진행하면 add는 단일 요소만 추가가능하기 때문에 update로 변경

기록기록기룩끼룩끼룩

쿼리 계획

쿼리 계획이란?

spark submit와 spark api

Spark submit이란?

Spark API란?

SparkSQL 기초(3)

SparkSQL 기초(2)

SparkSQL 기초(1)

DF과 SparkSQL 소개

Spark Dataframe 이란?

SparkSQL 이란?

Spark 기초(2)

Spark 기초(1)

RDD와 DF 차이점 짚고 넘어가기

Spark 간단히 짚고 넘어가기

Spark 환경 설정

Apache Spark 설치(window), jupyter 접속

RDD, Docker 소개

중간 정리

클러스터&스파크 아키텍쳐 소개

아파치 스파크 소개

백준 2804번 크로스워드 만들기

백준 4592번 중복을 없애자

구분 : 구현

문제 해석

코드 풀이

최종 코드

웹

1. Web Service Physical/SW Structures 요약

2. HTTP란?

3. 하이퍼텍스트란?

4. 정리

git 사용법

머신러닝 Pt.6

시계열데이터분석

머신러닝 Pt.5_2

비지도학습(Unsupervised Learning)

군집화(Clustering)

차원 축소

추천시스템 - Association rule(연관 규칙)

Apriori

FP- Growth

머신러닝 Pt.5_1

K-Fold Cross Validation

Validation(검증) 데이터 셋

하이퍼파라미터 최적화

KNN 정리

Naive Bayes 정리

Decision Tree(의사결정나무) 정리

앙상블(Ensemble) 정리

결정트리

결정트리란?

가지치기 조건

머신러닝 Pt.4

불순도(Impurity), 엔트로피(Entropy) 계산

IG 계산 → 불순도 측정(Entropy/Gini) → 모델 학습(Fitting) → 트리 성장 → 과적합

→ 가지치기(Pruning, Early Stopping)

앙상블(Ensemble)

Voting

Bagging(Bootstrap Aggregating)

Boosting

Random Forest

머신러닝 Pt.3

규제(Regularized)

릿지

라쏘

로지스틱 회귀(Logistic Regression)

머신러닝 Pt.2

Feature Scaling

머신러닝 Pt.1

1. 문제 정의

2. 데이터 수집

3. 데이터 전처리

4. 특징 추출

5. 학습 & 검증

회귀분석

상관관계 분석

통계학개론 : 추론과 검정

통계학 개론 : 확률분포