예니의 코딩일기

기초 확률 분포

예니ㅣ — Wed, 31 Jan 2024 16:25:35 +0900

강의

베르누이 분포

"이항변수"(Binary Varaibles)는 0과 1로 구성된 집합을 치역으로 갖는 확률변수 입니다.

이항 분포

베타 분포

기초 확률

예니ㅣ — Wed, 31 Jan 2024 16:15:26 +0900

강의

확률

"표본집합"은 실험의 결과로 발생하는 모든 결과의 집합 입니다.

"확률"은 집합의 부분집합을 실수값에 대응시키는 함수 입니다.

확률변수

"확률변수"(Random Variable)은 표본집합의 원소를 실수갑에 대응시키는 함수 입니다.

"연속확률변수"(Continuous Random Variable)은 누적분포함수를 가진 확률변수에 대해 다음 식을 만족하는 확률밀도함수가 존재하는 확률변수 입니다.

확률변수 성질

덧셈법칙(Sum Rule)

곱셈법칙(Product Rule)

베이즈 확률(Bayes)
- 사후확률(Posterior)
- 사전확률(Prior)
- 가능도 혹은 우도(Likelihood)
- 경계확률(Nomalization)

기댓값과 분산

"기댓값"(Expectation)은 확률분포 하에서 함수의 평균값 입니다.

이산확률분포

연속확률분포

근사

다변수

조건부 기댓값

"분산"(Variance)는 밀도함수의 값들이 기댓값으로부터 흩어져 있는 정도 입니다.

"공분산"(Covariance)는 두 개의 확률변수에 대한 공통 분산 입니다.

확률 해석 관점

빈도주의(Frequentist) : 반복가능한 사건들의 빈도수에 기반
베이지안(Bayesian) : 불확실성을 정량적으로 표현

기초 선형대수

예니ㅣ — Tue, 30 Jan 2024 11:22:21 +0900

강의

기본 표기법

벡터

import numpy as np
x = np.array(list)

행렬

import numpy as np
A = np.array([
    list1,
    list2
    ...
])

행렬의 곱셈

벡터 X 벡터

import numpy as np

# 내적
x = np.array(list1)
y = np.array(list2)
x.dot(y)

# 외적
x = np.expand_dims(x, axis=1)
y = np.expand_dims(y, axis=0)
np.matmul(x,y)

행렬 X 벡터

행렬 X 행렬

특수 행렬

정방행렬(Square Matrix) : 행과 열의 개수 동일
상삼각행렬(Upper Triangular Matrix) : 주대각선 아래 원소의 값이 모두 0인 정방행렬
하삼각행렬(Lower Triangular Matrix) : 주대각선 위 원소의 값이 모두 0인 정방행렬
대각행렬(Diagonal Matrix) : 주대각선 외의 모든 원소의 값이 0인 정방행렬

import numpy as np
np.diag(D)		# 주대각선 값

단위행렬(Identity Matrix) : 주대각선의 모든 원소의 값이 1인 대각행렬

import nupmy as np
I = np.eye(n)

연산

전치(Transpose)

A.T

대칭(Symmetic) : 행렬이 자신의 정방행렬과 동일
반대칭(Anti-Symmetric) : 행렬이 자신의 부호가 반대인 정방행렬과 동일
대각합(Trace) : 주대각선의 모든 원소들의 합

import numpy as np
np.trace(A)

놈(Norms) : 벡터의 길이

LA.norm(A)

선형독립

"선형독립"(Linear Independent)는 벡터들의 집합에 속해 있는 어떤 벡터도 나머지 벡터들의 선형조합으로 나타낼 수 없는 경우를 말합니다.

"종속"(Dependent)은 어떠한 벡터가 나머지 벡터들의 선형조합으로 나타낼 수 있는 경우를 말합니다.

Column Rank : 행렬의 열의 부분집합 중 가장 큰 선형독립인 집합의 크기
Row Rank : 행렬의 행의 부분집합 중 가장 큰 선형독립인 집합의 크기

LA.matrix_rank(A)

역행렬

"역행렬"(The Inverse)는 다음을 식을 만족하는 정방행렬 입니다.

LA.inv(A)

직교 행렬

"직교"(Orthogonal)는 다음 식을 만족하는 경우를 말합니다.

"직교행렬"은 모든 열이 서로 직교이고 정규화된 정방행렬 입니다.

공간

"생성"(Span)은 벡터의 집합이 다음 식을 만족하는 경우를 말합니다.

"치역"(Range)는 행렬의 모든 열들에 대한 생성 입니다.

"영공간"(Nullspace)은 행렬과 곱해졌을 때 0이 되는 모든 벡터들의 집합 입니다.

"투영"(Projection)은 치역 위에서 벡터가 다음 식을 만족하는 것을 말합니다.

행렬식

LA.det(A)

이차형식

고유값과 고유벡터

eigenvalues, eigenvectors = LA.eig(A)

행렬미분(Matrix Calculus)

The Gradient

The Hessian

적용예시

최소제곱법(Laest Squares)
고유값과 최적화문제(Eigenvalues as Optimization)
Autoencoder와 Principle Components Analysis(PCA)
최적의 D 찾기

머신러닝 소개

예니ㅣ — Mon, 29 Jan 2024 13:37:56 +0900

강의

Machine Learing

"Machine Learning"은 경험을 통해 자동으로 개선하는 컴퓨터 알고리즘 연구 입니다.

"Test Dataset"은 모델 평가를 위한 별도의 데이터 입니다.

학습 종류

지도 학습(Supervised Learning) : 목표값(Target)이 주어진 경우
- 분류(Classfication) : 목표값이 이산적인 경우
- 회귀(Regression) : 목표값이 연속적인 경우
비지도 학습(Unsupervised Learning) : 목표값(Target)이 없는 경우
- 군집(Clustering)

이론

확률 이론(Probability Theory) : 예측값의 불확실성을 정량적으로 표현할 수 있는 수학적인 프레임워크
결정 이론(Decision Theory) : 최적의 예측을 수행할 수 있는 방법론

"오차 함수"(Error Function)은 모델의 품질을 수치화하여 나타내는 함수 입니다.

"일반화"(Generalization)은 모델에서 이전에 접하지 못한 새로운 데이터에 대해 올바른 예측을 수행하는 역량 입니다.

오류

과소적합(Under-fitting)
과대적합(Over-fitting)

머신러닝 프로젝트 과정

큰 그림 확인
- 문제 정의
- 성능 측정 지표 선택
데이터 수집
- Test Dataset & Train Dataset
데이터 탐색 및 시각화
머신러닝 알고리즘 데이터 처리
- 데이터 정제
- 변환 파이프라인 구성
모델 선택 및 훈련
- 교차 검증
모델 상세 조정
- 그리드 탐색 혹은 랜덤 탐색
- 특성 중요도, 에러 분석
솔루션 제시
시스템 론칭 및 모니터링, 유지 보수

Kafka & Spark Streaming 연동 실습

예니ㅣ — Mon, 29 Jan 2024 13:10:27 +0900

실습

fake_people 토픽의 title top 10 계산하기

spark.jars.packages 설정
- spark-defaults.conf 파일 수정
- SparkSession 생성시 config 지정
- spark-submit 실행시 --packages 옵션 사용

# kafka_source_streaming.py

from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, expr
from pyspark.sql.types import StructType, StructField, StringType, LongType, DoubleType, IntegerType, ArrayType


if __name__ == "__main__":
    spark = SparkSession \
        .builder \
        .appName("File Streaming Demo") \
        .master("local[3]") \
        .config("spark.streaming.stopGracefullyOnShutdown", "true") \
        .getOrCreate()

    schema = StructType([
        StructField("id", StringType()),
        StructField("name", StringType()),
        StructField("title", StringType())
    ])

    kafka_df = spark.readStream \
        .format("kafka") \
        .option("kafka.bootstrap.servers", "localhost:9092") \
        .option("subscribe", "fake_people") \
        .option("startingOffsets", "earliest") \
        .load()
    kafka_df.printSchema()
    """
    |-- key: binary (nullable = true)
    |-- value: binary (nullable = true)
    |-- topic: string (nullable = true)
    |-- partition: integer (nullable = true)
    |-- offset: long (nullable = true)
    |-- timestamp: timestamp (nullable = true)
    |-- timestampType: integer (nullable = true)
    """
    value_df = kafka_df.select(from_json(col("value").cast("string"), schema).alias("value"))
    value_df.createOrReplaceTempView("fake_people")
    value_df.printSchema()
    count_df = spark.sql("SELECT value.title, COUNT(1) count FROM fake_people GROUP BY 1 ORDER BY 2 DESC LIMIT 10")

    count_writer_query = count_df.writeStream \
        .format("console") \
        .outputMode("complete") \
        .option("checkpointLocation", "chk-point-dir-json") \
        .start()

    print("Listening to Kafka")
    count_writer_query.awaitTermination()

spark-shell
    spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.1 kafka_source_streaming.py

Spark Streaming 소개 및 실습

예니ㅣ — Mon, 29 Jan 2024 13:02:02 +0900

강의

Spark Streaming

"Spark Streaming"는 실시간 데이터 스트림 처리를 위한 Spark API 입니다.

데이터 소스 : Kafk, Kinesis, Flume, TCP 소켓
고급 함수 사용 : Join, Map, Reduce, Window
웹 UI : localhost:4040

동작 방식

마이크로 배치로 데이터 처리
루프
새로운 데이터를 이전 데이터에 Merge 혹은 Replace
데이터 위치 관리
실패시 Fault Tolerance 및 데이터 재처리 관리
최종 결과 스트림 일괄 생성 : Spark Engine
- DStream
  - RDD 기반
  - Spark SQL 엔진의 최적화 기능 사용 불가
  - 이벤트 발생 시간 기반 처리 불가
- Structured Streaming
  - DataFrame 기반
  - Catalyst 기반 최적화 혜택
  - 이벤트 발생 시간 기반 처리 가능

내부 동작

구성 요소

Source
- 스트리밍 데이터를 수집하는 외부 시스템
- ReadStream 사용

lines_df = spark.readStream\
    .format("socket")\
    .option("host", "localhost")\
    .option("port", "9999")\
    .load()

Sink
- 수집한 데이터를 처리하여 출력하는 외부 시스템
- OutputMode : Append, Update, Complete

word_count_query = counts_df.writeStream\
    .format("console")\
    .outputMode("complete")\
    .option("checkpointLocation", "chk-point-dir")\
    .start()

실습

Streaming WordCount 예제

터미널 1 : Netcat을 데이터 Producer로 사용
터미널 2 : Spark Structured Streaming으로 생성한 Consumer 실행

# wordcount_streaming.py

from pyspark.sql import SparkSession
from pyspark.sql.functions import *


if __name__ == "__main__":
    spark = SparkSession \
        .builder \
        .appName("Streaming Word Count") \
        .master("local[3]") \
        .config("spark.streaming.stopGracefullyOnShutdown", "true") \
        .config("spark.sql.shuffle.partitions", 3) \
        .getOrCreate()

    # READ
    lines_df = spark.readStream \
        .format("socket") \
        .option("host", "localhost") \
        .option("port", "9999") \
        .load()

    # TRANSFORM
    words_df = lines_df.select(expr("explode(split(value,' ')) as word"))
    counts_df = words_df.groupBy("word").count()

    # SINK
    word_count_query = counts_df.writeStream \
        .format("console") \
        .outputMode("complete") \
        .option("checkpointLocation", "chk-point-dir") \
        .start()

    print("Listening to localhost:9999")
    word_count_query.awaitTermination()

# 터미널 1

nc -lk 9999

# 터미널 2

spark-submit wordcount_streaming.py

Kafka ksqlDB

예니ㅣ — Thu, 25 Jan 2024 13:31:42 +0900

강의

ksqlDB

"ksqlDB"는 REST API 혹은 ksql 클라이언트 툴을 이용하여 Topic을 테이블처러 SQL로 조작할 수 있는 방법 입니다.

docker ps
docker exec -it ContainerID sh

ksql
    CREATE STREAM my_stream (id STRING, name STRING, title STRING) with (kafka_topic='fake_peaple', value_format='JSON');
    SELECT * FROM my_stream;

Kafka 프로그래밍 실습

예니ㅣ — Thu, 25 Jan 2024 13:01:52 +0900

실습

랜덤하게 사람 정보 생성 및 저장하는 KafkaProducer 구현

Faker 모듈 사용
pydantic 모듈의 BaseModel 사용
Topic 생성 후 추가

pip install faker
pip install pydantic

# person.py

from pydantic import BaseModel

class Person(BaseModel):
    id: str
    name: str
    title: str

# fake_person_producer.py

import uuid
import json
from typing import List
from person import Person

from faker import Faker
from kafka.admin import NewTopic
from kafka.errors import TopicAlreadyExistsError
from kafka import KafkaAdminClient
from kafka.producer import KafkaProducer


def create_topic(bootstrap_servers, name, partitions, replica=1):
    client = KafkaAdminClient(bootstrap_servers=bootstrap_servers)
    try:
        topic = NewTopic(
            name=name,
            num_partitions=partitions,
            replication_factor=replica)
        client.create_topics([topic])
    except TopicAlreadyExistsError as e:
        print(e)
        pass
    finally:
        client.close()


def main():
    topic_name = "fake_people"
    bootstrap_servers = ["localhost:9092"]

    # create a topic first
    create_topic(bootstrap_servers, topic_name, 4)

    # ingest some random people events
    people: List[Person] = []
    faker = Faker()
    producer = KafkaProducer(
        bootstrap_servers=bootstrap_servers,
        client_id="Fake_Person_Producer",
        
    )

    for _ in range(100):
        person = Person(id=str(uuid.uuid4()), name=faker.name(), title=faker.job().title())
        people.append(person)
        producer.send(
            topic=topic_name,
            key=person.title.lower().replace(r's+', '-').encode('utf-8'),
            value=person.json().encode('utf-8'))

    producer.flush()

if __name__ == '__main__':
    main()

랜덤하게 저장된 사람 정보 확인하는 KafkaConsumer 구현

Offset Auto Commit : True

import json

from kafka.consumer import KafkaConsumer


def key_deserializer(key):
    return key.decode('utf-8')


def value_deserializer(value):
    return json.loads(value.decode('utf-8'))


def main():
    topic_name = "fake_people"
    bootstrap_servers = ["localhost:9092"]
    consumer_group_id = "fake_people_group"

    consumer = KafkaConsumer(
        bootstrap_servers=bootstrap_servers,
        group_id=consumer_group_id,
        key_deserializer=key_deserializer,
        value_deserializer=value_deserializer,
        auto_offset_reset='earliest',
        enable_auto_commit=True)

    consumer.subscribe([topic_name])
    for record in consumer:
        print(f"""
            Consumed person {record.value} with key '{record.key}'
            from partition {record.partition} at offset {record.offset}
        """)


if __name__ == '__main__':
    main()

Offset Auto Commit : False

import json

from kafka import TopicPartition, OffsetAndMetadata
from kafka.consumer import KafkaConsumer


def key_deserializer(key):
    return key.decode('utf-8')


def value_deserializer(value):
    return json.loads(value.decode('utf-8'))


def main():
    topic_name = "fake_people"
    bootstrap_servers = ["localhost:9092"]
    consumer_group_id = "manual_fake_people_group"

    consumer = KafkaConsumer(
        bootstrap_servers=bootstrap_servers,
        group_id=consumer_group_id,
        key_deserializer=key_deserializer,
        value_deserializer=value_deserializer,
        auto_offset_reset='earliest',
        enable_auto_commit=False)

    consumer.subscribe([topic_name])
    for record in consumer:
        print(f"""
            Consumed person {record.value} with key '{record.key}'
            from partition {record.partition} at offset {record.offset}
        """)

        topic_partition = TopicPartition(record.topic, record.partition)
        offset = OffsetAndMetadata(record.offset + 1, record.timestamp)
        consumer.commit({
            topic_partition: offset
        })

if __name__ == '__main__':
    main()

Kafka 프로그래밍

예니ㅣ — Wed, 24 Jan 2024 13:31:04 +0900

강의

Kafka 프로그래밍 언어

Java
- Apache Kafka Java Client
- Spring Kafka
Python
- Confluent Kafka Python
- Kafka-Python

pip install kafka-python

.NET
- Confluent Kafka .NET
Go
- Sarama
Node.js
- node-rdkafka
- kafka-node

Kafka 기본 프로그래밍

Producer 생성

from time import sleep
from json import dumps
from kafka import KafkaProducer

producer = KafkaProducer(
   bootstrap_servers=['localhost:9092'],
   value_serializer=lambda x: dumps(x).encode('utf-8')
)

for j in range(999):
   print("Iteration", j)
   data = {'counter': j}
   producer.send('topic_test', value=data)
   sleep(0.5)

Consumer 객체 생성

from json import loads
from time import sleep

consumer = KafkaConsumer(
   'topic_test',
   bootstrap_servers=['localhost:9092'],
   auto_offset_reset='earliest',
   enable_auto_commit=True,
   group_id='my-group-id',
   value_deserializer=lambda x: loads(x.decode('utf-8'))
)
for event in consumer:
   event_data = event.value
   # Do whatever you want
   print(event_data)
   sleep(2)

Topic 생성

client = KafkaAdminClient(bootstrap_servers=bootstrap_servers)
topic = NewTopic(
	name=name,
	num_partitions=partitions,
	replication_factor=replica)
client.create_topics([topic])

Kafka Client Tool

Producer와 Consumer를 각각 터미널에서 실행하면 Side-by-side로 메세지가 발생하는 것을 확인할 수 있습니다.

docker exec -it Broker_Container_ID sh

kafka-topics
kafka-topics --bootstrap-server kafka1:9092 --list
kafka-topics --bootstrap-server kafka1:9092 --delete --topic topic_test

kafka-configs

kafka-console-consumer
kafka-console-consumer --bootstrap-server kafka1:9092 --topic test_console --from-beginning

kafka-console-producer
kafka-console-producer --bootstrap-server kafka1:9092 --topic test_console
	Hellow World
    Bye

Topic 파라미터

KafkaProducer

bootstrap_servers : 브로커 리스트
client_id : Producer 이름
key_serializer, value_serializer : serialize 방법 지정
enable_idempotence : 중복 메세지 전송 결정
acks: 0, 1, 'all'
retries : 재시도 횟수
delivery.timeout.ms : 메세지 전송 최대 시간
linger_ms, batch_size : 배치 전송

KafkaConsumer

bootstrap_servers : 브로커 리스트
client_id : Consumer 이름
group_id : Consumer Group 이름
key_deserializer, value_deserializer : serialize 방법 지정
auto_offset_reset
enable_auto_commit

Message Processing Guarantee 방식

Exactly Once
At Least Once
At Most Once

Kafka 설치

예니ㅣ — Wed, 24 Jan 2024 13:16:36 +0900

강의

Kafka 설치

Docker Compose 사영
Github repo 사용 : https://github.com/conduktor/kafka-stack-docker-compose
- full-stack.yml
- zk-single-kafka-single.yml
- zk-single-kafka-multiple.yml
- zk-multiple-kafka-single.yml
- zk-multiple-kafka-multiple.yml
Kafka 웹 UI
- localhost:8080
- ID : admin@admin.io / Password : admin

git clone https://github.com/conduktor/kafka-stack-docker-compose
cd kafka-stack-docker-compose
docker compose -f full-stack.yml up		# 컴퓨터 사양이 좋은 경우
docker compose -f zk-single-kafka-single.yml up		# 컴퓨터 사양이 안좋은 경우