첨부파일 ai(딥러닝) 과제 보고서.py 파일 다운로드 # 기본문법 my_list = [10, 'hello list', 20] print(my_list[1]) my_list_2 = [[10, 20, 30], [40, 50, 60]] print(my_list_2[1][1]) import numpy as np my_arr = np.array([[10, 20, 30], [40, 50, 60]]) print(my_arr) type(my_arr) my_arr[0][2] np.sum(my_arr) print(my_arr[1][0]) import matplotlib.pyplot as plt plt.plot([1, 2, 3, 4, 5], [1, 4, 9, 16, 25]) # x 좌표와 y 좌표를 파이썬 리스트로 전달합니다. plt.show() plt.scatter([1, 2, 3, 4, 5], [1, 4, 9, 16, 25]) plt.show() x = np.random.randn(1000) #
첨부파일 딥러닝입문.1207.py 파일 다운로드 # 훈련 노하우 import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split cancer = load_breast_cancer() x = cancer.data y = cancer.target x_train_all, x_test, y_train_all, y_test = train_test_split(x, y, stratify=y, test_size=0.2, random_state=42) from sklearn.linear_model import SGDClassifier sgd = SGDClassifier(loss='log', random_state=42) sgd.fit(x_train_all, y_train_all) sgd.scor
첨부파일 딥러닝입문.1208.py 파일 다운로드 # 다중분류 신경망 import numpy as np class MultiClassNetwork: def __init__(self, units=10, batch_size=32, learning_rate=0.1, l1=0, l2=0): self.units = units # 은닉층의 뉴런 개수 self.batch_size = batch_size # 배치 크기 self.w1 = None # 은닉층의 가중치 self.b1 = None # 은닉층의 절편 self.w2 = None # 출력층의 가중치 self.b2 = None # 출력층의 절편 self.a1 = None # 은닉층의 활성화 출력 self.losses = [] # 훈련 손실 self.val_losses = [] # 검증 손실 self.lr = learning_rate # 학습률 self.l1 = l1 # L1 손실 하이퍼파라미터 self.l2 = l2 # L2 손실 하이퍼파라미터
첨부파일 딥러닝입문.1209.py 파일 다운로드 # 합성곱 import numpy as np w = np.array([2, 1, 5, 3]) x = np.array([2, 8, 3, 7, 1, 2, 0, 4, 5]) w_r = np.flip(w) print(w_r) w[0:4:2] for i in range(6): print(np.dot(x[i:i+4], w_r)) from scipy.signal import convolve convolve(x, w, mode='valid') from scipy.signal import correlate correlate(x, w, mode='valid') correlate(x, w, mode='full') correlate(x, w, mode='same') x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) w = np.array([[2, 0], [0, 0]]) from scipy.signal import corr
첨부파일 딥러닝입문.1219.py 파일 다운로드 # 텍스트 분류 # 순환 신경망 생성 import numpy as np from tensorflow.keras.datasets import imdb (x_train_all, y_train_all), (x_test, y_test) = imdb.load_data(skip_top=20, num_words=100) print(x_train_all[0]) for i in range(len(x_train_all)): x_train_all[i] = [w for w in x_train_all[i] if w > 2] print(x_train_all[0]) word_to_index = imdb.get_word_index() word_to_index['movie'] index_to_word = {word_to_index[k]: k for k in word_to_index} for w in x_train_all[0]: print(index_to_word[w
첨부파일 py221219.py 파일 다운로드 a = 5 b = 7 c = a + b print(c) import numpy as np x=np.array([1,2,3]) x.__class__ x.shape x.ndim w = np.array([[1,2,3],[4,5,6]]) w.shape w.ndim w = np.array([[1,2,3],[4,5,6]]) x = np.array([[0,1,2],[3,4,5]]) w+x w*x A= np.array([[1,2],[3,4]]) A*10 A= np.array([[1,2],[3,4]]) b= np.array([10,20]) A*b a = np.array([1,2,3]) b = np.array([4,5,6]) np.dot(a,b) A= np.array([[1,2],[3,4]]) B= np.array([[5,6],[7,8]]) np.matmul(A,B) import numpy as np w1 = np.random.randn(2,4) b1 =
문제 # 주어진 데이터 셋에서 f2가 0값인 데이터를 age를 기준으로 오름차순 정렬하고 # 앞에서 부터 20개의 데이터를 추출한 후 # f1 결측치(최소값)를 채우기 전과 후의 분산 차이를 계산하시오 (소수점 둘째 자리까지) # - 데이터셋 : basic1.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - File -> Editor Type -> Script 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic1.csv") dfage = df[df["f2"]==0].sort_values("age").head(20) dfmin = dfage.fillna(dfage["f1"].min()) round(dfage["f1"].var()-dfmin["f1"].var(),2) 코드사용 sort_values : 정렬 fillna : 결측치 대체 var : 분산
문제 2022년 5월 sales의 중앙값을 구하시오 데이터셋 : basic2.csv 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic2.csv") df["Date"]=pd.to_datetime(df["Date"],format='%Y-%m-%d') df["Sales"][df["Date"].between('2022-05-01','2022-05-31')].median() 사용코드 to_datetime : 데이터 형태를 변화 between : 사이값을 찾기위해
문제 주어진 데이터에서 2022년 5월 주말과 평일의 sales컬럼 평균값 차이를 구하시오 (소수점 둘째자리까지 출력, 반올림) 데이터셋 : basic2.csv 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic2.csv", parse_dates=['Date']) df["Date"]=pd.to_datetime(df["Date"]) df5 = df[(df["Date"].dt.month == 5)& (df["Date"].dt.year == 2022)] df1 = df5[df["Date"].dt.dayofweek.isin([5,6])]["Sales"].mean() df2 = df5[df["Date"].dt.dayofweek.isin([0,1,2,3,4,])]["Sales"].mean() round((df1-df2),2) 코드사용 to_datetime : 날짜로 형태 변환 dt.month : 월별 추출
정답 주어진 데이터에서 2022년 월별 Sales 합계 중 가장 큰 금액과 2023년 월별 Sales 합계 중 가장 큰 금액의 차이를 절대값으로 구하시오. 단 Events컬럼이 '1'인경우 80%의 Salse값만 반영함 (최종값은 소수점 반올림 후 정수 출력) 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic2.csv", parse_dates=['Date']) df["Date"] = pd.to_datetime(df["Date"]) df22 = df[df["Date"].dt.year == 2022] def appl(x): if x["Events"] == 1 : x["Sales"]= x["Sales"]*0.8 elif x["Events"] != 1 : x["Sales"]=x["Sales"] return x df22 = df22.apply(lambda x : appl(x), axis=1) df22
문제 고객과 잘 맞는 타입 추천 :) basic1 데이터와 basic3 데이터를 'f4'값을 기준으로 병합하고, 병합한 데이터에서 r2결측치를 제거한다음, 앞에서 부터 20개 데이터를 선택하고 'f2'컬럼 합을 구하시오 basic1.csv: 고객 데이터 basic3.csv: 잘 어울리는 관계 데이터 (추천1:r1, 추천2:r2) 풀이 import pandas as pd b1 = pd.read_csv("../input/bigdatacertificationkr/basic1.csv") b3 = pd.read_csv("../input/bigdatacertificationkr/basic3.csv") b2 = pd.merge(b1,b3, how='left',on="f4") b2[~b2["r2"].isnull()].head(20)["f2"].sum() 코드사용 merge : 데이터 합치기 isnull : 결측치 확인
첨부파일 B4_통계 기법을 활용한 데이터 분석 및 시각화 보고서.pdf 파일 다운로드 첨부파일 B4_rcode.R 파일 다운로드 첨부파일 B4_pythoncode.py 파일 다운로드
문제 나이 구간 나누기 basic1 데이터 중 'age'컬럼 이상치를 제거하고, 동일한 개수로 나이 순으로 3그룹으로 나눈 뒤 각 그룹의 중앙값을 더하시오 (이상치는 음수(0포함), 소수점 값) data: basic1.csv 풀이 import pandas as pd df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df["age"].describe() dfage = df[(df["age"]>0) &(df["age"]==round(df["age"],0))] dfage = dfage.sort_values(by = "age",ascending=False) dfage["age1"] = pd.qcut(dfage["age"],3,labels=[1,2,3]) dfage.groupby("age1")["age"].median().sum() 코드사용 sort_values : 순차적으로 변경 qcut : 분할
문제 주어진 데이터(basic2.csv)에서 주 단위 Sales의 합계를 구하고, 가장 큰 값을 가진 주와 작은 값을 가진 주의 차이를 구하시오(절대값) 데이터셋 : basic2.csv 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic2.csv", parse_dates=['Date'], index_col=0) df.head() df["sale2"]=df["Sales"].resample("W").sum() df["sale2"].max()-df["sale2"].min() 코드사용 resample : 주간별 샘플링
문제 f1의 결측치를 채운 후 age 컬럼의 중복 제거 전과 후의 'f1' 중앙값 차이를 구하시오 - 결측치는 f1의 데이터 중 내림차순 정렬 후 10번째 값으로 채움 - 중복 데이터 발생시 뒤에 나오는 데이터를 삭제함 - 최종 결과값은 절대값으로 출력 데이터셋 : basic1.csv 풀이 import pandas as pd df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df = df.sort_values(by="f1") df["f1"] = df["f1"].fillna(df["f1"].iloc[9]) df1 = df.drop_duplicates(["age"]) abs(df["f1"].median()-df1["f1"].median()) 코드사용 sort_values : 내림차순 fillna : 결측치 대처 drop_duplicates : 중복제거
문제 주어진 데이터(basic2.csv)에서 "pv"컬럼으로 1일 시차(lag)가 있는 새로운 컬럼을 만들고(예: 1월 2일에는 1월 1일 pv데이터를 넣고, 1월 3일에는 1월 2일 pv데이터를 넣음),새로운 컬럼의 1월 1일은 다음날(1월 2일)데이터로 결측치를 채운 다음, Events가 1이면서 Sales가 1000000이하인 조건에 맞는 새로운 컬럼 합을 구하시오 데이터셋 : basic2.csv 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic2.csv") df["Date"] = pd.to_datetime(df["Date"]) df["PV1"] = df["PV"].shift(1) df = df.fillna(method = "bfill") df[(df["Events"]==1)&(df["Sales"]<1000000)]["PV1"].sum() 코드사용 to_datetime : 형태 변환 sh
문제 결측치 제거 및 그룹 합계에서 조건에 맞는 값 찾아 출력 주어진 데이터 중 basic1.csv에서 'f1'컬럼 결측 데이터를 제거하고, 'city'와 'f2'을 기준으로 묶어 합계를 구하고, 'city가 경기이면서 f2가 0'인 조건에 만족하는 f1 값을 구하시오 데이터셋 : basic1.csv 풀이 # 라이브러리 및 데이터 불러오기 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df.head() df_dropna = df.dropna(subset = ["f1"]) df_fn = df_dropna.groupby(["city","f2"]).sum() df_fn = df_fn.loc["경기",0]["f1"] df_fn 코드 dropna : 결측치 제거 grouby : city, f2 기준으로 계산하기위해서
문제 'f4'컬럼의 값이 'ESFJ'인 데이터를 'ISFJ'로 대체하고, 'city'가 '경기'이면서 'f4'가 'ISFJ'인 데이터 중 'age'컬럼의 최대값을 출력하시오! 데이터셋 : basic1.csv 풀이 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df.head() df.loc[df["f4"]=="ESFJ"] = 'ISFJ' df.loc[(df["f4"]== "ISFJ")&(df["city"]=="경기")]["age"].max() 사용코드 max : 최고값을 찾기위해 사용
문제 주어진 데이터 셋에서 'f2' 컬럼이 1인 조건에 해당하는 데이터의 'f1'컬럼 누적합을 계산한다. 이때 발생하는 누적합 결측치는 바로 뒤의 값을 채우고, 누적합의 평균값을 출력한다. (단, 결측치 바로 뒤의 값이 없으면 다음에 나오는 값을 채워넣는다) 데이터셋 : basic1.csv 풀이 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df.head(2) df_cumsum = df[df["f2"]==1]["f1"].cumsum() df_cumsum.fillna(method="bfill").mean() 사용코드 cumsum : 누적합 fillna(method="bfill") : 결측치 변경 mean : 평균
문제 수치형 변수 변환하기 주어진 데이터에서 'f5'컬럼을 표준화(Standardization (Z-score Normalization))하고 그 중앙값을 구하시오 데이터셋 : basic1.csv 풀이 # 라이브러리 및 데이터 불러오기 import pandas as pd import numpy as np from sklearn.preprocessing import StandardScaler df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') scaler = StandardScaler() scaler.fit(df[["f5"]]) df["f5"]=scaler.fit_transform(df[["f5"]]) df["f5"].median() 사용코드 StandardScaler : 표준화 fi_tranform : 데이터정규화
문제 수치형 변수 변환하기 주어진 데이터에서 20세 이상인 데이터를 추출하고 'f1'컬럼을 결측치를 최빈값으로 채운 후, f1 컬럼의 여-존슨과 박스콕스 변환 값을 구하고, 두 값의 차이를 절대값으로 구한다음 모두 더해 소수점 둘째 자리까지 출력(반올림)하시오 데이터셋 : basic1.csv 해결 import pandas as pd import numpy as np from sklearn.preprocessing import power_transform df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df20 = df[df["age"]>=20] many = df20["f1"].mode() df20["f1"] = df20["f1"].fillna(many[0]) df20["a"] = power_transform(df20[["f1"]],standardize=False) df20["b"] = power_transform(df2
문제 # min-max스케일링 기준 상하위 5% 구하기 # 주어진 데이터에서 'f5'컬럼을 min-max 스케일 변환한 후, # 상위 5%와 하위 5% 값의 합을 구하시오 # - 데이터셋 : basic1.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - File -> Editor Type -> Script 해결 import pandas as pd import numpy as np from sklearn.preprocessing import MinMaxScaler df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') min_max_scaler = MinMaxScaler() df["scaler"] = min_max_scaler.fit_transform(df[["f5"]]) print(df.head()) scaler = df["scaler"] (scaler.quantile(0.05)+scaler.q
문제 # 주어진 데이터에서 상위 10개 국가의 접종률 평균과 하위 10개 국가의 접종률 평균을 구하고, 그 차이를 구해보세요 # (단, 100%가 넘는 접종률 제거, 소수 첫째자리까지 출력) # - 데이터셋 : ../input/covid-vaccination-vs-death/covid-vaccination-vs-death_ratio.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - File -> Editor Type -> Script 풀이 import pandas as pd df = pd.read_csv("../input/covid-vaccination-vs-death/covid-vaccination-vs-death_ratio.csv") dfmax = df.groupby("country")["ratio"].max() print(dfmax.tail()) dfmax = dfmax.sort_values(ascending = False) dfmax = dfm
문제 # 상관관계 구하기 # 주어진 데이터에서 상관관계를 구하고, quality와의 상관관계가 가장 큰 값과, 가장 작은 값을 구한 다음 더하시오! # 단, quality와 quality 상관관계 제외, 소수점 둘째 자리까지 출력 # - 데이터셋 : ../input/red-wine-quality-cortez-et-al-2009/winequality-red.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - 스크립트 방식 권장: File -> Editor Type -> Script 해설 import pandas as pd import numpy as np df = pd.read_csv("../input/red-wine-quality-cortez-et-al-2009/winequality-red.csv") print(df.head()) dfcor = df.corr() dfmax = abs(dfcor[dfcor["quality"]!=1]["quality"]).
문제 # city와 f4를 기준으로 f5의 평균값을 구한 다음, f5를 기준으로 상위 7개 값을 모두 더해 출력하시오 (소수점 둘째자리까지 출력) # - 데이터셋 : basic1.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - File -> Editor Type -> Script 풀이 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic1.csv") df.head() dfgr=df.groupby(["city","f4"])["f5"].mean() round(dfgr.reset_index().sort_values("f5",ascending = False).head(7)["f5"].sum(),2) 코드사용 groupby : city, f4 기준으로 f5를 평균 reset_index : f5로 다시 정렬 sort_values : 순차적으로 변경
문제 # %% [code] # 주어진 데이터 셋에서 age컬럼 상위 20개의 데이터를 구한 다음 # f1의 결측치를 중앙값으로 채운다. # 그리고 f4가 ISFJ와 f5가 20 이상인 # f1의 평균값을 출력하시오! # - 데이터셋 : basic1.csv # - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # - File -> Editor Type -> Script 해결 import pandas as pd df = pd.read_csv("../input/bigdatacertificationkr/basic1.csv") dfage = df.sort_values("age",ascending=False).head(20) dfage = dfage.fillna(dfage["f1"].median()) dfage["f1"][(dfage["f4"] =="ISFJ")&(dfage["f5"]>=20)].mean() 코드사용 sort_values : 순서 정령 fillna : 결측치 대처
첨부파일 1122_training.R 파일 다운로드 # 토픽모델링 # 06-2 -------------------------------------------------------------------- # 기생충 기사 댓글 불러오기 library(readr) library(dplyr) raw_news_comment <- read_csv("news_comment_parasite.csv") %>% mutate(id = row_number()) # ------------------------------------------------------------------------- library(stringr) library(textclean) # 기본적인 전처리 news_comment <- raw_news_comment %>% mutate(reply = str_replace_all(reply, "[^가-힣]", " "), reply = str_squish(reply)) %>% # 중복 댓글
첨부파일 1123_training.R 파일 다운로드 # 데이터 시각화 # 1단계: 차트 작성을 위한 자료 만들기 chart_data <- c(305, 450, 320, 460, 330, 480, 380, 520) names(chart_data) <- c("2018 1분기", "2019 1분기", "2018 2분기", "2019 2분기", "2018 3분기", "2019 3분기", "2018 4분기", "2019 4분기") str(chart_data) chart_data # 2단계: 세로 막대 차트 그리기 barplot(chart_data, ylim = c(0, 600), col = rainbow(8), main = "2018년도 vs 2019년도 매출현항 비교") barplot(chart_data, ylim = c(0, 600), ylab = "매출액(단위: 만원)", xlab = "년도별 분기 현황", col = rainbow(8), main= "2018년도 vs 2019년도 매출
첨부파일 1124_training.R 파일 다운로드 # # 실습 (lattice 패키지 사용 준비하기) # 1단계: lattice 패키지 설치 # install.packages("lattice") library(lattice) # 2단계: 실습용 테이터 가져오기 # install.packages("mlmRev") library(mlmRev) data("Chem97") str(Chem97) head(Chem97, 30) Chem97 # 실습 (score 변수를 조건변수로 지정하여 데이터 시각화하기) histogram(~gcsescore | score, data = Chem97) histogram(~gcsescore | factor(score), data = Chem97) # 실습 (densityplot()함수를 사용하여 밀도 그래프 그리기) densityplot(~gcsescore | factor(score), data = Chem97, groups = gender, plot.Poin
첨부파일 데이터 분석 및 시각화.py 파일 다운로드
문제 ## 이상치를 찾아라 ### 데이터에서 IQR을 활용해 Fare컬럼의 이상치를 찾고, 이상치 데이터의 여성 수를 구하시오 - 강의 영상 : https://youtu.be/ipBW5D_UJEo - 데이터셋 : titanic - 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 - 데이터 위치 "../input/titanic/train.csv" (copy&edit가 아닐 경우 별도로 데이터셋 불러와야 함) 풀이 import pandas as pd import numpy as np df = pd.read_csv('../input/titanic/train.csv') df["Fare"].describe() q1=df["Fare"].quantile(0.25) q3=df["Fare"].quantile(0.75) iqr=q3-q1 df_iqr = df["Fare"]<q1-1.5*iqr df_iqr1 = df["Fare"]>q3+1.5*iqr df_df = df[df_iqr|df_i
문제 이상치를 찾아라(소수점 나이) 주어진 데이터에서 이상치(소수점 나이)를 찾고 올림, 내림, 버림(절사)했을때 3가지 모두 이상치 'age' 평균을 구한 다음 모두 더하여 출력하시오 풀이 # 라이브러리 및 데이터 불러오기 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df.head() df = df[(df["age"]-np.floor(df["age"]))!=0] df df_mean = np.floor(df["age"]).mean()+np.ceil(df["age"]).mean()+np.round(df["age"].mean()) df_mean 사용함수 floor = 소수점 내림 ceil = 소수점 올림 round = 소수점 반올림
문제 ## 결측치 처리 - 주어진 데이터에서 결측치가 80%이상 되는 컬럼은(변수는) 삭제하고, 80% 미만인 결측치가 있는 컬럼은 'city'별 중앙값으로 값을 대체하고 'f1'컬럼의 평균값을 출력하세요! - 데이터셋 : basic1.csv 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 해결 # 라이브러리 및 데이터 불러오기 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') df.head() df_bool = df.isnull().sum()/len(df.index) < 0.8 df_loc = df.loc[:,df_bool] df_city = df_loc.groupby("city")['f1'].median() df_fillna = df_loc.fillna(df_city) df['f1'] = df['f1'].fillna(df['city'].
문제 # 왜도와 첨도 구하기 # 주어진 데이터 중 train.csv에서 'SalePrice'컬럼의 왜도와 첨도를 구한 값과, # 'SalePrice'컬럼을 스케일링(log1p)로 변환한 이후 왜도와 첨도를 구해 # 모두 더한 다음 소수점 2째자리까지 출력하시오 # 데이터셋 : House Prices - Advanced Regression Technique (https://www.kaggle.com/c/house-prices-advanced-regression-techniques) # 오른쪽 상단 copy&edit 클릭 -> 예상문제 풀이 시작 # 강의 영상 : https://youtu.be/_ft7ZlDlk7c 풀이 import pandas as pd import numpy as np df = pd.read_csv("../input/house-prices-advanced-regression-techniques/train.csv") df_skew = df['SalePrice'].ske
문제 조건에 맞는 데이터 표준편차 구하기¶ 주어진 데이터 중 basic1.csv에서 'f4'컬럼 값이 'ENFJ'와 'INFP'인 'f1'의 표준편차 차이를 절대값으로 구하시오 데이터셋 : basic1.csv 해결 import pandas as pd import numpy as np df = pd.read_csv('../input/bigdatacertificationkr/basic1.csv') ENFJ = df[df["f4"]=="ENFJ"]["f1"].std() INFP = df[df["f4"]=="INFP"]["f1"].std() abs(ENFJ-INFP) 사용코드 std : 표준편차 abs : 절대값
첨부파일 1116_training.R 파일 다운로드 # 텍스트마이닝 # install.packages("multilinguer") library(multilinguer) # install_jdk() # install.packages("remotes") # remotes::install_github("haven-jeon/KoNLP", upgrade = "never", INSTALL_opts = c("--no-multiarch")) # install.packages(c("stringr", "hash", "tau", "Sejong", "RSQLite", "devtools"),type = "binary") # install.packages("rJava") # install.packages ("wordcloud") # install.packages ("tm") library(KoNLP) useNIADic() # install.packages("Sejong") # install.packages
첨부파일 04 감정 분석_e.pdf 파일 다운로드 첨부파일 R_TM_4.감정분석.pdf 파일 다운로드 첨부파일 08.텍스트+마이닝+기반+데이터+분석(LM2001010508_15v1) (1).pdf 파일 다운로드
첨부파일 1117_training.R 파일 다운로드 # 감정분석 # 04-1 -------------------------------------------------------------------- # 감정 사전 불러오기 install.packages("readr") library(readr) dic <- read_csv("knu_sentiment_lexicon.csv") # ------------------------------------------------------------------------- library(dplyr) # 긍정 단어 dic %>% filter(polarity == 2) %>% arrange(word) # 부정 단어 dic %>% filter(polarity == -2) %>% arrange(word) # ------------------------------------------------------------------------- dic %>% f
첨부파일 02 형태소 분석기 이용 단어 빈도 분석_e.pdf 파일 다운로드 첨부파일 R_TM_2.형태소분석기이용빈도분석.pdf 파일 다운로드
첨부파일 1118_training.R 파일 다운로드 # 형태소분석기 이용 빈도분석 # 02-1 -------------------------------------------------------------------- # install.packages("multilinguer") library(multilinguer) # install_jdk() # install.packages(c("stringr", "hash", "tau", "Sejong", "RSQLite", "devtools"), # type = "binary") # install.packages("remotes") # remotes::install_github("haven-jeon/KoNLP", # upgrade = "never", # INSTALL_opts = c("--no-multiarch")) library(KoNLP) useNIADic() # -----------------------------------------
첨부파일 03 비교 분석_오즈비_TF-IDF.pdf 파일 다운로드 첨부파일 R_TM_3.비교분석_오즈비_TF-IDF.pdf 파일 다운로드
첨부파일 1121_training.R 파일 다운로드 library(dplyr) # 문재인 대통령 연설문 불러오기 raw_moon <- readLines("speech_moon.txt", encoding = "UTF-8") moon <- raw_moon %>% as_tibble() %>% mutate(president = "moon") # 박근혜 대통령 연설문 불러오기 raw_park <- readLines("speech_park.txt", encoding = "UTF-8") park <- raw_park %>% as_tibble() %>% mutate(president = "park") bind_speeches <- bind_rows(moon, park) %>% select(president, value) # 기본적인 전처리 library(stringr) speeches <- bind_speeches %>% mutate(value = str_replace_all(value, "[^가
첨부파일 1115_training.R 파일 다운로드 # xgboos # 1단계: 패키지 설치 install.packages("xgboost") library(xgboost) # 2단계: y변수 생성 iris_label <- ifelse(iris$Species == 'setosa', 0, ifelse(iris$Species == 'versicolor', 1, 2)) table(iris_label) iris$label <- iris_label # 3단계: data set 생성 idx <- sample(nrow(iris), 0.7 * nrow(iris)) train <- iris[idx, ] test <- iris[-idx, ] # 4단계: matrix 객체 변환 train_mat <- as.matrix(train[-c(5:6)]) dim(train_mat) train_lab <- train$label length(train_lab) # 5단계: xgb.DMatrix 객체 변환 dtrai
import torch import torch.nn as nn import torch.optim as optim sentence = "Repeat is the best medicine for memory".split() vocab = list(set(sentence)) print(vocab) word2index = {tkn: i for i, tkn in enumerate(vocab, 1)} # 단어에 고유한 정수 부여 word2index['<unk>']=0 print(word2index) print(word2index['memory']) # 수치화된 데이터를 단어로 바꾸기 위한 사전 index2word = {v: k for k, v in word2index.items()} print(index2word) print(index2word[2]) def build_data(sentence, word2index): encoded = [word2index[token] for token in
첨부파일 1114_training.R 파일 다운로드 # 연관분석 # 1단계: 연관분석을 위한 패키지 설치 install.packages("arules") library(arules) # 2단계: 트랜잭션(transaction) 객체 생성 setwd("C:/Rwork/ ") tran <- read.transactions("tran.txt", format = "basket", sep = ",") tran # 3단계: 트랜잭션 데이터 보기 inspect(tran) # 4단계: 규칙(rule) 발견1 rule <- apriori(tran, parameter = list(supp = 0.3, conf = 0.1)) inspect(rule) # 5단계: 규칙(rule) 발견2 rule <- apriori(tran, parameter = list(supp = 0.1, conf = 0.1)) inspect(rule) # 2.2 트랜잭션 객체 생성 # 실습 (single 트랜잭션 객체 생성) set
첨부파일 오라클PL_SQL_2_221019.pdf 파일 다운로드
첨부파일 R과 python을 이용한 Oracle DB접근_221021.pdf 파일 다운로드
첨부파일 1111_training.R 파일 다운로드 # 베이지안 # 실습. # ================ install.packages("e1071") install.packages("caret") library(e1071) data <- read.csv(file = "heart.csv", header = T) head(data) str(data) library(caret) set.seed(1234) tr_data <- createDataPartition(y=data$AHD, p=0.7, list=FALSE) tr <- data[tr_data,] te <- data[-tr_data,] Bayes <- naiveBayes(AHD~. ,data=tr) Bayes predicted <- predict(Bayes, te, type="class") table(predicted, te$AHD) AHD <- as.factor(te$AHD) confusionMatrix(predicted, AH
import numpy as np timesteps = 10 # 시점의 수. NLP에서는 보통 문장의 길이가 된다. input_size = 4 # 입력의 차원. NLP에서는 보통 단어 벡터의 차원이 된다. hidden_size = 8 # 은닉 상태의 크기. 메모리 셀의 용량이다. inputs = np.random.random((timesteps, input_size)) # 입력에 해당되는 2D 텐서 hidden_state_t = np.zeros((hidden_size,)) # 초기 은닉 상태는 0(벡터)로 초기화 # 은닉 상태의 크기 hidden_size로 은닉 상태를 만듬. print(hidden_state_t) # 8의 크기를 가지는 은닉 상태. 현재는 초기 은닉 상태로 모든 차원이 0의 값을 가짐. Wx = np.random.random((hidden_size, input_size)) # (8, 4)크기의 2D 텐서 생성. 입력에 대한 가중치. Wh = np.random.ran
import torch import torch.nn as nn import torch.optim as optim import numpy as np input_str = 'apple' label_str = 'pple!' char_vocab = sorted(list(set(input_str+label_str))) vocab_size = len(char_vocab) print ('문자 집합의 크기 : {}'.format(vocab_size)) char_to_index = dict((c, i) for i, c in enumerate(char_vocab)) # 문자에 고유한 정수 인덱스 부여 print(char_to_index) index_to_char={} for key, value in char_to_index.items(): index_to_char[value] = key print(index_to_char) x_data = [char_to_index[c] for c in input_s
import torch import torch.nn as nn import torch.optim as optim import numpy as np sentence = ("if you want to build a ship, don't drum up people together to " "collect wood and don't assign them tasks and work, but rather " "teach them to long for the endless immensity of the sea.") char_set = list(set(sentence)) # 중복을 제거한 문자 집합 생성 char_dic = {c: i for i, c in enumerate(char_set)} # 각 문자에 정수 인코딩 print(char_dic) # 공백도 여기서는 하나의 원소 dic_size = len(char_dic) print('문자 집합의 크기 : {}'.format(dic_size)) #
첨부파일 오라클 SQL1_8_221017.pdf 파일 다운로드
첨부파일 오라클 SQL2_3_221018.pdf 파일 다운로드
첨부파일 로지스틱 회귀분석_221104.pdf 파일 다운로드 첨부파일 9주차_로지스틱회귀분석.pdf 파일 다운로드
첨부파일 시계열분석6_221107.pdf 파일 다운로드 첨부파일 sm_time_series.pdf 파일 다운로드 첨부파일 GGPLOT_시계열그래프.pdf 파일 다운로드
첨부파일 R_ch2_데이터유형과구조_220921.pdf 파일 다운로드 첨부파일 R ch2 연습문제2_220922.pdf 파일 다운로드
첨부파일 R_ch7 EDA와 data정제_220928.pdf 파일 다운로드
첨부파일 R_ch13_집단간 차이분석_221025.pdf 파일 다운로드
pip install konlpy from konlpy.tag import Okt okt = Okt() token = okt.morphs("나는 자연어 처리를 배운다") print(token) word2index = {} for voca in token: if voca not in word2index.keys(): word2index[voca] = len(word2index) print(word2index) def one_hot_encoding(word, word2index): one_hot_vector = [0]*(len(word2index)) index = word2index[word] one_hot_vector[index] = 1 return one_hot_vector one_hot_encoding("처리",word2index)
import torch # 원-핫 벡터 생성 dog = torch.FloatTensor([1, 0, 0, 0, 0]) cat = torch.FloatTensor([0, 1, 0, 0, 0]) computer = torch.FloatTensor([0, 0, 1, 0, 0]) netbook = torch.FloatTensor([0, 0, 0, 1, 0]) book = torch.FloatTensor([0, 0, 0, 0, 1]) print(torch.cosine_similarity(cat, cat, dim=0)) print(torch.cosine_similarity(cat, computer, dim=0)) print(torch.cosine_similarity(computer, netbook, dim=0)) print(torch.cosine_similarity(netbook, book, dim=0))
첨부파일 11010_training.R 파일 다운로드 # 인공신경망 # 실습 (간단한 인공신경망 모델 생성) # 1단계: 패키지 설치 install.packages("nnet") library(nnet) # 2단계: 데이터 셋 생성 # 데이터프레임 생성 - 입력 변수(x)와 출력변수(y) df = data.frame( x2 = c(1:6), x1 = c(6:1), y = factor(c('no', 'no', 'no', 'yes', 'yes', 'yes')) ) str(df) # 3단계: 인공신경망 모델 생성 model_net = nnet(y ~ ., df, size = 1) # 4단계: 모델 결과 변수 보기 model_net # 5단계: 가중치(weights)보기 summary(model_net) # 6단계: 분류모델의 적합값 보기 model_net$fitted.values # 7단계: 분류모델의 예측치 생성과 분류 정확도 p <- predict(model_net, df, type
import torch train_data = 'you need to know how to code' # 중복을 제거한 단어들의 집합인 단어 집합 생성. word_set = set(train_data.split()) # 단어 집합의 각 단어에 고유한 정수 맵핑. vocab = {word: i+2 for i, word in enumerate(word_set)} vocab['<unk>'] = 0 vocab['<pad>'] = 1 print(vocab) # 단어 집합의 크기만큼의 행을 가지는 테이블 생성. embedding_table = torch.FloatTensor([ [ 0.0, 0.0, 0.0], [ 0.0, 0.0, 0.0], [ 0.2, 0.9, 0.3], [ 0.1, 0.5, 0.7], [ 0.2, 0.1, 0.8], [ 0.4, 0.1, 0.1], [ 0.1, 0.8, 0.9], [ 0.6, 0.1, 0.1]]) sample = 'you need to run'.split()
첨부파일 3.data_loading_n_storage_part_n1_220913.pdf 파일 다운로드
첨부파일 4.DataCleaning_Preparation_n1_220913.pdf 파일 다운로드
첨부파일 5.DataWrangling_n1_220913.pdf 파일 다운로드
첨부파일 6.data_aggregation_group_operations_n1_220913.pdf 파일 다운로드
# 1번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 1, out_channel = 32, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스풀링(kernel_size=2, stride=2)) # 2번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 32, out_channel = 64, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스풀링(kernel_size=2, stride=2)) # 3번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 64, out_channel = 128, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스풀링(kernel_size=2, stride=2, padding=1)) # 4번 레이어 : 전결합층(Fu
en_text = "A Dog Run back corner near spare bedrooms" import spacy spacy_en = spacy.load('en_core_web_sm') def tokenize(en_text): return [tok.text for tok in spacy_en.tokenizer(en_text)] print(tokenize(en_text)) !pip install nltk import nltk nltk.download('punkt') from nltk.tokenize import word_tokenize print(word_tokenize(en_text)) kor_text = "사과의 놀라운 효능이라는 글을 봤어. 그래서 오늘 사과를 먹으려고 했는데 사과가 썩어서 슈퍼에 가서 사과랑 오렌지 사왔어" print(kor_text.split()) !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Co
%matplotlib inline import matplotlib.pyplot as plt # 시각화를 위한 맷플롯립 from sklearn.datasets import load_digits digits = load_digits() # 1,979개의 이미지 데이터 로드 print(digits.images[0]) print(digits.target[0]) print('전체 샘플의 수 : {}'.format(len(digits.images))) images_and_labels = list(zip(digits.images, digits.target)) for index, (image, label) in enumerate(images_and_labels[:5]): # 5개의 샘플만 출력 plt.subplot(2, 5, index + 1) plt.axis('off') plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest') plt.tit
첨부파일 1109_training.R 파일 다운로드 # 실습 (의사결정 트리 생성: ctree()함수 이용) # 1단계: party패키지 설치 install.packages("party") library(party) # 2단계: airquality 데이터셋 로딩 library(datasets) str(airquality) # 3단계: formula생성 formula <- Temp ~ Solar.R + Wind + Ozone # 4단계: 분류모델 생성 – formula를 이용하여 분류모델 생성 air_ctree <- ctree(formula, data = airquality) air_ctree # 5단계: 분류분석 결과 plot(air_ctree) # 1단계: 학습데이터와 검정데이터 샘플링 #set.seed(1234) idx <- sample(1:nrow(iris), nrow(iris) * 0.7) train <- iris[idx, ] test <- iris[-idx, ] # 2단계:
# 1번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 1, out_channel = 32, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스풀링(kernel_size=2, stride=2)) # 2번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 32, out_channel = 64, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스풀링(kernel_size=2, stride=2)) # 3번 레이어 : 전결합층(Fully-Connected layer) 특성맵을 펼친다. # batch_size × 7 × 7 × 64 → batch_size × 3136 전결합층(뉴런 10개) + 활성화 함수 Softmax import torch import torch.nn as nn # 배치 크기 × 채널 × 높이(height) ×
import torch import torch.nn.functional as F torch.manual_seed(1) z = torch.FloatTensor([1, 2, 3]) hypothesis = F.softmax(z, dim=0) print(hypothesis) hypothesis.sum() z = torch.rand(3, 5, requires_grad=True) hypothesis = F.softmax(z, dim=1) print(hypothesis) y = torch.randint(5, (3,)).long() print(y) # 모든 원소가 0의 값을 가진 3 × 5 텐서 생성 y_one_hot = torch.zeros_like(hypothesis) y_one_hot.scatter_(1, y.unsqueeze(1), 1) print(y.unsqueeze(1)) cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean() pr
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_train = [[1, 2, 1, 1], [2, 1, 3, 2], [3, 1, 3, 4], [4, 1, 5, 5], [1, 7, 5, 5], [1, 2, 5, 6], [1, 6, 6, 6], [1, 7, 7, 7]] y_train = [2, 2, 2, 1, 1, 1, 0, 0] x_train = torch.FloatTensor(x_train) y_train = torch.LongTensor(y_train) print(x_train.shape) print(y_train.shape) torch.Size([8, 4]) torch.Size([8]) y_one_hot = torch.zeros(8, 3) y_one_hot.scatter_(1, y_train.unsqueeze(1), 1)
첨부파일 1103_training.R 파일 다운로드 # 회귀분석 # 1단계: 데이터 가져오기 product <- read.csv("product.csv", header = TRUE) str(product) # 2단계: 독립변수와 종속변수 생성 y = product$제품_만족도 x = product$제품_적절성 df <- data.frame(x, y) # 3단계: 단순 선형회귀 모델 생성 result.lm <- lm(formula = y ~ x, data = df) # 4단계: 회귀분석의 절편과 기울기 result.lm # 5단계: 모델의 적합값과 잔차 보기 names(result.lm) # 5-1단계: 적합값 보기 fitted.values(result.lm)[1:2] # 5-2단계: 관측값 보기 head(df, 1) # 5-3단계: 회귀방정식을 적용하여 모델의 적합값 계산 Y = 0.7789 + 0.7393 * 4 Y # 5-4단계: 잔차(오차) 계산 3 - 3.735963 # 실습
for X, Y in data_loader: # 입력 이미지를 [batch_size × 784]의 크기로 reshape # 레이블은 원-핫 인코딩 X = X.view(-1, 28*28) import torch import torchvision.datasets as dsets import torchvision.transforms as transforms from torch.utils.data import DataLoader import torch.nn as nn import matplotlib.pyplot as plt import random USE_CUDA = torch.cuda.is_available() # GPU를 사용가능하면 True, 아니라면 False를 리턴 device = torch.device("cuda" if USE_CUDA else "cpu") # GPU 사용 가능하면 사용하고 아니면 CPU 사용 print("다음 기기로 학습합니다:", device) # for re
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) print(x_train) print(x_train.shape) print(y_train) print(y_train.shape) # 가중치 W를 0으로 초기화하고 학습을 통해 값이 변경되는 변수임을 명시함. W = torch.zeros(1, requires_grad=True) # 가중치 W를 출력 print(W) b = torch.zeros(1, requires_grad=True) print(b) hypothesis = x_train * W + b print(hypothesis) # 앞서 배운 torch.mean으로 평균
import torch w = torch.tensor(1.0, requires_grad=True) y = w**2 z = 2*y + 5 print(w) print(y) print(z) z.backward() print('수식을 w로 미분한 값 : {}'.format(w.grad))
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) # 훈련 데이터 x1_train = torch.FloatTensor([[73], [93], [89], [96], [73]]) x2_train = torch.FloatTensor([[80], [88], [91], [98], [66]]) x3_train = torch.FloatTensor([[75], [93], [90], [100], [70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) # 가중치 w와 편향 b 초기화 w1 = torch.zeros(1, requires_grad=True) w2 = torch.zeros(1, requires_grad=True) w3 = torch.zeros(1, requires
첨부파일 1102_training.R 파일 다운로드 # 요인분석 # 프레임생성 s1 <- c(1, 2, 1, 2, 3, 4, 2, 3, 4, 5) s2 <- c(1, 3, 1, 2, 3, 4, 2, 4, 3, 4) s3 <- c(2, 3, 2, 3, 2, 3, 5, 3, 4, 2) s4 <- c(2, 4, 2, 3, 2, 3, 5, 3, 4, 1) s5 <- c(4, 5, 4, 5, 2, 1, 5, 2, 4, 3) s6 <- c(4, 3, 4, 4, 2, 1, 5, 2, 4, 2) name <- 1:10 subject <- data.frame(s1, s2, s3, s4, s5, s6) str(subject) # 주성분 분석으로 요인 수 알아보기 pc <- prcomp(subject) summary(pc) plot(pc) prcomp(subject) # 교유값으로 요인수 분석 en <- eigen(cor(subject)) names(en) en$values en$vectors plot
import torch.nn as nn #model = nn.Linear(input_dim, output_dim) import torch.nn.functional as F #cost = F.mse_loss(prediction, y_train) import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(1) # 데이터 x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) # 모델을 선언 및 초기화. 단순 선형 회귀이므로 input_dim=1, output_dim=1. model = nn.Linear(1,1) print(list(model.parameters())) # optimizer 설정. 경사 하강법 SGD를 사용하고 learning rate를 의미하는 lr은 0.01 optimize
import torch import torch.nn as nn import torch.nn.functional as F # 모델을 선언 및 초기화. 단순 선형 회귀이므로 input_dim=1, output_dim=1. model = nn.Linear(1,1) class LinearRegressionModel(nn.Module): # torch.nn.Module을 상속받는 파이썬 클래스 def __init__(self): super().__init__() self.linear = nn.Linear(1, 1) # 단순 선형 회귀이므로 input_dim=1, output_dim=1. def forward(self, x): return self.linear(x) class MultivariateLinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(3, 1) # 다중 선형
import torch import torch.nn as nn import torch.nn.functional as F from torch.utils.data import TensorDataset # 텐서데이터셋 from torch.utils.data import DataLoader # 데이터로더 x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) dataset = TensorDataset(x_train, y_train) dataloader = DataLoader(dataset, batch_size=2, shuffle=True) model = nn.Linear(3,1) optimizer = torch.optim.SGD(model.paramet
class CustomDataset(torch.utils.data.Dataset): def __init__(self): 데이터셋의 전처리를 해주는 부분 def __len__(self): 데이터셋의 길이. 즉, 총 샘플의 수를 적어주는 부분 def __getitem__(self, idx): 데이터셋에서 특정 1개의 샘플을 가져오는 함수 import torch import torch.nn.functional as F from torch.utils.data import Dataset from torch.utils.data import DataLoader # Dataset 상속 class CustomDataset(Dataset): def __init__(self): self.x_data = [[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]] self.y_data = [[152], [185], [180], [196]
%matplotlib inline import numpy as np # 넘파이 사용 import matplotlib.pyplot as plt # 맷플롯립사용 def sigmoid(x): # 시그모이드 함수 정의 return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y = sigmoid(x) plt.plot(x, y, 'g') plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() x = np.arange(-5.0, 5.0, 0.1) y1 = sigmoid(0.5*x) y2 = sigmoid(x) y3 = sigmoid(2*x) plt.plot(x, y1, 'r', linestyle='--') # W의 값이 0.5일때 plt.plot(x, y2, 'g') # W의 값이 1일때 plt.plot(x, y3, 'b', linestyle='--') # W의
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) model = nn.Sequential( nn.Linear(2, 1), # input_dim = 2, output_dim = 1 nn.Sigmoid() # 출력은 시그모이드 함수를 거친다 ) model(x_train) # optimizer 설정 optimizer = optim.SGD(model.parameters(), lr=1) nb_epochs = 1000 for epoch in
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) class BinaryClassifier(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(2, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): return self.sigmoid(self.linear(x)) model = BinaryClassifier
첨부파일 1021_SQL.py 파일 다운로드 첨부파일 1021_SQL.R 파일 다운로드 import cx_Oracle import os # 한글 지원 환경 os.putenv('NLS_LANG', '.UTF8') # Path 설정 LOCATION = r"C:/instantclient_21_7" os.environ["PATH"] = LOCATION + ";" + os.environ["PATH"] # DB 연결 connect = cx_Oracle.connect("scott", "tiger", "localhost:1521/xe") cs = connect.cursor() # 데이터 추가(insert) sql = "insert into py_table values('kang', '1234', '강감찬', 45)" cs.execute(sql) # SQL 문 cs.execute("select * from py_table") # SQL 문 for i in cs: # data 보기 print(i) #
첨부파일 R과 python을 이용한 Oracle DB접근_221021.pdf 파일 다운로드 1 R과 python으로 Oracle DB에 접근 1. R R에서 DB에 연결 https://db.rstudio.com/getting-started/connect-to-database # Ch9 Oracle DB # R 3.6.3 # 사전작업 # # 1. C:드라이브에 OracleTest 폴더 생성 # 2. OracleTest폴더에 driver ojdbc6 저장 # ojdbc6 위치 # C:\oraclexe\app\oracle\product\11.2.0\server\jdbc\lib # 3. SQL developer에서 scott계정으로 table 생성 # # create table test_table( # id varchar(50) primary key, # pass varchar(30) not null, # name varchar(25) not null, # age number(2) # );
첨부파일 R_ch13_집단간 차이분석_221025.pdf 파일 다운로드 # 전체 표본 크기(N): 10,000명 # 표본 평균(X): 165.1cm # 표본 표준편차(S): 2cm N = 10000 X = 165.1 S = 2 low <- X -1.96 * S / sqrt(N) high <- X + 1.96 * S / sqrt(N) low; high # 실습 (신뢰구간으로 표본오차 구하기) high - X (low - X) * 100 (high - X) * 100 # 1단계: 실습 데이터 가져오 setwd("C:/Rwork/ ") data <- read.csv("one_sample.csv", header = TRUE) head(data) x <- data$survey # 2단계: 빈도수와 비율계산 summary(x) length(x) table(x) # 3단계: 패키지를 이용하여 빈도수와 비율 계산 install.packages("prettyR") library(prettyR) fr
첨부파일 1026_training.R 파일 다운로드 통계 # SJH # 1. 교육 방법에 따라 시험성적에 차이가 있는지 검정하시오 # (힌트. 두 집단 평균 차이 검정) # 1) 데이터셋: twomethod.csv # 2) 변수: method(교육방법), score(시험성적) # 3) 모델: 교육방법(명목) -> 시험성적(비율) # 4) 전처리, 결측치 제거 setwd("C:/Rwork/ ") data <- read.csv("twomethod.csv", header = TRUE) head(data) data<- na.omit(data) #na 제거 a <- subset(data, method ==1) b <- subset(data, method ==2) a <- a$score b <- b$score #동절성 확인 var.test(a, b) #두 집단 평균 차이 검정(양측검정) t.test(a, b, altr = "two.sided", conf.int = TRUE, conf.level
첨부파일 비모수검정.pdf 파일 다운로드
adsp 자격증 공부 첨부파일 Eduatoz_ADsP_1과목_데이터의_이해_220226.pdf 파일 다운로드 첨부파일 Eduatoz_ADsP_2과목_데이터_분석_기획_220228.pdf 파일 다운로드 첨부파일 Eduatoz_ADsP_3과목_PART1_R_220425.pdf 파일 다운로드 첨부파일 Eduatoz_ADsP_3과목_PART2_01_220228.pdf 파일 다운로드 첨부파일 Eduatoz_ADsP_3과목_PART2_02_기초통계분석_시계열분석_220228.pdf 파일 다운로드 첨부파일 Eduatoz_ADsP_3과목_PART3_정형데이터마이닝_220505.pdf 파일 다운로드
첨부파일 R_ch12_교차분석_카이제곱검정5_221031.pdf 파일 다운로드 # SJH library(ggplot2) library(gmodels) # 1. 직업 유형에 따른 응답 정도에 차이가 있는가를 단계별로 검정하시오 (동질성 검정) # 1) 파일 가져오기 data <- read.csv("Response.csv") # 2) 코딩변경 - 리코딩 data$job1[data$job == 1] <- "학생" data$job1[data$job == 2] <- "직장인" data$job1[data$job == 3] <- "주부" data$response1[data$response == 1] <- "무응답" data$response1[data$response == 2] <- "낮음" data$response1[data$response == 1] <- "높음" # 3) 교차 분할표 작성 x <- data$job1 y <- data$response1 table(x, y) # 4) 동질성 검정
첨부파일 1101_training.R 파일 다운로드 # 상관분석 # 데이터가져오기 product <- read.csv("C:/Rwork/product.csv", header = TRUE) head(product) # 기술통계량 summary(product) sd(product$제품_친밀도); sd(product$제품_적절성); sd(product$제품_만족도) # 1단계: 변수 간의 상관계수 보기 cor(product$제품_친밀도, product$제품_적절성) cor(product$제품_친밀도, product$제품_만족도) # 2단계: 제품_적절성과 제품_만족도의 상관계수 보기 cor(product$제품_적절성, product$제품_만족도) # 3단계: (제품_적절성+제품_친밀도)와 제품_만족도의 상관계수 보기 cor(product$제품_적절성 + product$제품_친밀도, product$제품_만족도) install.packages("corrgram") library(corrgra
import numpy as np import torch t = np.array([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]) ft = torch.FloatTensor(t) print(ft.shape) print(ft.view([-1, 3])) # ft라는 텐서를 (?, 3)의 크기로 변경 print(ft.view([-1, 3]).shape) print(ft.view([-1, 1, 3])) print(ft.view([-1, 1, 3]).shape) ft = torch.FloatTensor([[0], [1], [2]]) print(ft) print(ft.shape) print(ft.squeeze()) print(ft.squeeze().shape) ft = torch.Tensor([0, 1, 2]) print(ft.shape) print(ft.unsqueeze(0)) # 인덱스가 0부터 시작하므로 0은 첫번째 차원을 의미한다. print(f
import numpy as np t = np.array([0., 1., 2., 3., 4., 5., 6.]) # 파이썬으로 설명하면 List를 생성해서 np.array로 1차원 array로 변환함. print(t) print('Rank of t: ', t.ndim) print('Shape of t: ', t.shape) print('t[0] t[1] t[-1] = ', t[0], t[1], t[-1]) # 인덱스를 통한 원소 접근 print('t[2:5] t[4:-1] = ', t[2:5], t[4:-1]) # [시작 번호 : 끝 번호]로 범위 지정을 통해 가져온다. print('t[:2] t[3:] = ', t[:2], t[3:]) # 시작 번호를 생략한 경우와 끝 번호를 생략한 경우 t = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]]) print(t) print('Rank of t: ', t.ndim
import torch result = 0 def add(num): global result result += num return result print(add(3)) print(add(4)) result1 = 0 result2 = 0 def add1(num): global result1 result1 += num return result1 def add2(num): global result2 result2 += num return result2 print(add1(3)) print(add1(4)) print(add2(3)) print(add2(7)) class Calculator: def __init__(self): # 객체 생성 시 호출될 때 실행되는 초기화 함수. 이를 생성자라고 한다. self.result = 0 def add(self, num): # 객체 생성 후 사용할 수 있는 함수. self.result += num return self.result cal1 = Calc
문제 설명 양의 정수 x가 하샤드 수이려면 x의 자릿수의 합으로 x가 나누어져야 합니다. 예를 들어 18의 자릿수 합은 1+8=9이고, 18은 9로 나누어 떨어지므로 18은 하샤드 수입니다. 자연수 x를 입력받아 x가 하샤드 수인지 아닌지 검사하는 함수, solution을 완성해주세요. 제한 조건 x는 1 이상, 10000 이하인 정수입니다. 입출력 예 arr return 10 true 12 true 11 false 13 false 입출력 예 설명 입출력 예 #1 10의 모든 자릿수의 합은 1입니다. 10은 1로 나누어 떨어지므로 10은 하샤드 수입니다. 입출력 예 #2 12의 모든 자릿수의 합은 3입니다. 12는 3으로 나누어 떨어지므로 12는 하샤드 수입니다. 입출력 예 #3 11의 모든 자릿수의 합은 2입니다. 11은 2로 나누어 떨어지지 않으므로 11는 하샤드 수가 아닙니다. 입출력 예 #4 13의 모든 자릿수의 합은 4입니다. 13은 4로 나누어 떨어지지 않으므로 13은 하
문제 설명 함수 solution은 정수 n을 매개변수로 입력받습니다. n의 각 자릿수를 큰것부터 작은 순으로 정렬한 새로운 정수를 리턴해주세요. 예를들어 n이 118372면 873211을 리턴하면 됩니다. 제한 조건 n은 1이상 8000000000 이하인 자연수입니다. 입출력 예 n return 118372 873211 정답 def solution(n): answer = [] for i in str(n): answer.append(i) answer.sort(reverse=True) answer =''.join(answer) answer = int(answer) return answer 실행 결과 채점을 시작합니다. 정확성 테스트 테스트 1 〉 통과 (0.02ms, 10.4MB) 테스트 2 〉 통과 (0.02ms, 10.3MB) 테스트 3 〉 통과 (0.02ms, 10.4MB) 테스트 4 〉 통과 (0.02ms, 10.4MB) 테스트 5 〉 통과 (0.02ms, 10.4MB) 테스트
문제 설명 1937년 Collatz란 사람에 의해 제기된 이 추측은, 주어진 수가 1이 될 때까지 다음 작업을 반복하면, 모든 수를 1로 만들 수 있다는 추측입니다. 작업은 다음과 같습니다. 1-1. 입력된 수가 짝수라면 2로 나눕니다. 1-2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다. 2. 결과로 나온 수에 같은 작업을 1이 될 때까지 반복합니다. 예를 들어, 주어진 수가 6이라면 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야 하는지 반환하는 함수, solution을 완성해 주세요. 단, 주어진 수가 1인 경우에는 0을, 작업을 500번 반복할 때까지 1이 되지 않는다면 –1을 반환해 주세요. 제한 사항 입력된 수, num은 1 이상 8,000,000 미만인 정수입니다. 입출력 예 n result 6 8 16 4 626331 -1 입출력 예 설명 입출력 예 #1 문제의 설명과 같습니다.
첨부파일 오라클 SQL1_8_221017.pdf 파일 다운로드 첨부파일 scott1.sql 파일 다운로드 commit; desc salesman; create table board ( num number(4), title varchar2(30), author varchar2(12), content varchar2(600), writeday date default sysdate ); desc board; alter table salesman add (sal number(7, 2)); desc salesman; alter table salesman modify (sal number(10, 2)); desc salesman; alter table salesman drop (sal); desc salesman; drop table salesman; select * from tab; show recyclebin; flashback table salesman to before drop; se
첨부파일 오라클 SQL2_3_221018.pdf 파일 다운로드 첨부파일 scott2.sql 파일 다운로드 select avg(sal) from emp group by deptno; select max(sal) from emp group by deptno having max(sal) > 500; create table myboard ( num number(4) primary key, author varchar2(12), title varchar2(30), content varchar2(60) ); create sequence myboard_seq; insert into myboard(num, author, title, content) values(myboard_seq.nextval, '전우치', '제목','내용이다.'); select * from emp, dept; select empno, ename, sal, dept.deptno from emp, dept where emp.dept
첨부파일 1019.sql 파일 다운로드 첨부파일 오라클 SQL2_3_221018.pdf 파일 다운로드 set serveroutput on; begin dbms_output.put_line('안녕 PL/SQL'); end; / -- 화면 출력기능을 활성화한다. set serveroutput on; -- 스칼라 변수를 선언한다. declare sonno number(4); sonname varchar2(12); -- 실행문을 시작한다. begin sonno := 1001; sonname := '홍길동'; dbms_output.put_line(' 사번 이름'); dbms_output.put_line(' ---------------'); dbms_output.put_line(' ' || sonno || ' ' || sonname); -- 실행문을 종료한다. end; / -- 화면 출력기능을 활성화한다. set serveroutput on; -- 레퍼런스 변수를 선언한다. declare so
첨부파일 1020.sql 파일 다운로드 -- 저장 프로시저에 사용할 테이블을 emp 테이블에서 복사한다. create table empcopy as select*from emp; / -- 생성한 테이블의 정보를 조회한다. select * from empcopy; / -- 저장 프로시저를 생성한다. create or replace procedure del_all is begin -- empcopy 테이블의 저장된 데이터를 삭제한다. delete from empcopy; -- 트랜잭션 작업이 성공하여 완료한다. commit; end; / -- 저장 프로시저를 실행하여 empcopy 테이블에 저장된 데이터를 삭제한다. execute del_all; / -- 저장 프로시저에 대한 실행을 확인한다. select * from empcopy; / -- user_source 시스템 테이블의 구조를 확인한다. desc user_source; -- 저장 프로시저의 코드를 확인한다. select nam
문제 설명 정수 n을 입력받아 n의 약수를 모두 더한 값을 리턴하는 함수, solution을 완성해주세요. 제한 사항 n은 0 이상 3000이하인 정수입니다. 입출력 예 n return 12 28 5 6 입출력 예 설명 입출력 예 #1 12의 약수는 1, 2, 3, 4, 6, 12입니다. 이를 모두 더하면 28입니다. 입출력 예 #2 5의 약수는 1, 5입니다. 이를 모두 더하면 6입니다. 정답 def solution(n): answer = [] for i in range(1, n+1): if (n % i == 0) : answer.append(i) answer = sum(answer) return answer 실행 결과 테스트 1 입력값 〉 12 기댓값 〉 28 실행 결과 〉 테스트를 통과하였습니다. 테스트 2 입력값 〉 5 기댓값 〉 6 실행 결과 〉 테스트를 통과하였습니다. 테스트 결과 (~˘˘)~ 2개 중 2개 성공
첨부파일 11.pdf 파일 다운로드 첨부파일 12.pdf 파일 다운로드 첨부파일 13.pdf 파일 다운로드
문제 설명 자연수 N이 주어지면, N의 각 자릿수의 합을 구해서 return 하는 solution 함수를 만들어 주세요. 예를들어 N = 123이면 1 + 2 + 3 = 6을 return 하면 됩니다. 제한사항 N의 범위 : 100,000,000 이하의 자연수 입출력 예 N answer 123 6 987 24 입출력 예 설명 입출력 예 #1 문제의 예시와 같습니다. 입출력 예 #2 9 + 8 + 7 = 24이므로 24를 return 하면 됩니다. 정답 def solution(n): answer = 0 word = str(n) for i in range(len(word)): answer += int(word[i]) return answer 실행 결과 테스트 1 입력값 〉 123 기댓값 〉 6 실행 결과 〉 테스트를 통과하였습니다. 테스트 2 입력값 〉 987 기댓값 〉 24 실행 결과 〉 테스트를 통과하였습니다. 테스트 결과 (~˘˘)~ 2개 중 2개 성공
# Ch11 기술통계분석 # 1.1 빈도분석 # 빈도분석(Frequency Analysis) # 명목척도 또는 서열척도 같은 범주형 데이터를 대상으로 비율을 측정하는데 주로 이용 # 명목척도: 명목상 의미 없는 수치로 표현. 예) 거주지역, 성별 # 서열척도: 계급 순위를 수치로 표현. 예) 직급, 학력 수준 # 빈도수, 비율 등으로 나타냄 # 1.2 기술통계분석 # 등간척도나 비율척도와 같은 연속적 데이터를 분석할 때 이용 # 등간척도: 속성의 간격이 일정한 값을 갖는 변수. 예) 만족도 조사의 보기 # 비율척도: 등간척도의 특성에 절대 원점이 존재하는 척도. 0을 기준으로 한 수치. # 사칙연산이 가능. 예) 성적, 나이, 수량, 길이, 금액 # 2. 척도별 기술통계량 구하기 # 실습 (전체 데이터 셋의 특성 보기) # 1단계: 데이터 셋 가져오기 setwd("C:/Rwork/ ") data <- read.csv("descriptive.csv", header = TRUE) hea
문제 설명 임의의 양의 정수 n에 대해, n이 어떤 양의 정수 x의 제곱인지 아닌지 판단하려 합니다. n이 양의 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 양의 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요. 제한 사항 n은 1이상, 50000000000000 이하인 양의 정수입니다. 입출력 예 n return 121 144 3 -1 입출력 예 설명 입출력 예#1 121은 양의 정수 11의 제곱이므로, (11+1)를 제곱한 144를 리턴합니다. 입출력 예#2 3은 양의 정수의 제곱이 아니므로, -1을 리턴합니다. 정답 def solution(n): answer = 0 number = n ** 0.5 if number == int(number): answer = (number+1)**2 else : answer = -1 return answer 테스트 1 입력값 〉 121 기댓값 〉 144 실행 결과 〉 테스트를 통과하였습니다. 테스트 2 입력값 〉 3 기댓값
첨부파일 1014.sql 파일 다운로드 첨부파일 데이터베이스_SQL1_6_221014.pdf 파일 다운로드 desc emp; select * from tab; select username from all_users; select empno, ename, hiredate from emp where lower(ename) ='ford'; select empno, ename, hiredate from emp where ename =upper('ford'); select deptno, initcap(dname), initcap(loc) from dept where deptno = 10; select deptno, dname, concat(deptno, dname) from dept where deptno = 10; select substr(ename, 1, 2) from emp; select deptno, dname, length(dname) from dept where deptno = 1
문제 설명 자연수 n을 뒤집어 각 자리 숫자를 원소로 가지는 배열 형태로 리턴해주세요. 예를들어 n이 12345이면 [5,4,3,2,1]을 리턴합니다. 제한 조건 n은 10,000,000,000이하인 자연수입니다. 입출력 예 n return 12345 [5,4,3,2,1] 정답 def solution(n): answer = [] for i in str(n): answer.append(i) answer = list(map(int,answer)) answer.sort(reverse=True) return answer 실행 결과 테스트 1 입력값 〉 12345 기댓값 〉 [5, 4, 3, 2, 1] 실행 결과 〉 테스트를 통과하였습니다. 테스트 결과 (~˘˘)~ 1개 중 1개 성공
문제 설명 대문자와 소문자가 섞여있는 문자열 s가 주어집니다. s에 'p'의 개수와 'y'의 개수를 비교해 같으면 True, 다르면 False를 return 하는 solution를 완성하세요. 'p', 'y' 모두 하나도 없는 경우는 항상 True를 리턴합니다. 단, 개수를 비교할 때 대문자와 소문자는 구별하지 않습니다. 예를 들어 s가 "pPoooyY"면 true를 return하고 "Pyy"라면 false를 return합니다. 제한사항 문자열 s의 길이 : 50 이하의 자연수 문자열 s는 알파벳으로만 이루어져 있습니다. 입출력 예 s answer "pPoooyY" true "Pyy" false 입출력 예 설명 입출력 예 #1 'p'의 개수 2개, 'y'의 개수 2개로 같으므로 true를 return 합니다. 입출력 예 #2 'p'의 개수 1개, 'y'의 개수 2개로 다르므로 false를 return 합니다. 정답 def solution(s): s = s.lower() if s.co
R code에 기반한 2021년 코로나 데이터 분석 2022.10.14 A2팀(신정훈, 조아진, 임성구, 조성운) 목차 1. 분석 개요 2. 팀원 간 의견 수렴 3. 데이터 전처리 및 분석 3.1 전처리 과정 3.2 문제풀이 4. 검증 4.1 음수 데이터 원인 4.2 NaN 값 원인 4.3가설 검증 5. 결론 6. 별첨 1. 분석 개요 - 제공된 데이터셋은 Johns’ Hopkins 대학 내 The Center For Systems Science and Engineering(CSSE) 에서 업데이트하는 전 세계 코로나 (COVID-19) 발생 현황 데이터셋이다. 제공된 데이터셋 중 2021년 일간 데이터에서 python code로 다음을 수행하고 결과를 팀별로 리포트하시오. 1.1 일별 국가별 코로나 발생자 수와 사망자 수를 기준으로 전처리하시오. 일부 국가는 지역별로 코로나 발생자 수와 사망자 수가 분리되어 있으니 국가별로 집계하고 국가, 총발생자 수, 총사망자 수, 일평균 발생자
첨부파일 [정답] 2020 개념쎈 확통.pdf 파일 다운로드
첨부파일 10.pdf 파일 다운로드
짝수와 홀수 문제 설명 정수 num이 짝수일 경우 "Even"을 반환하고 홀수인 경우 "Odd"를 반환하는 함수, solution을 완성해주세요. 제한 조건 num은 int 범위의 정수입니다. 0은 짝수입니다. 입출력 예 num return 3 "Odd" 4 "Even" 정답 def solution(num) : if num%2 != 0 : return "Odd" elif num%2 == 0 : return "Even" 주의상항 문제에서 반환을 요청시 retrun으로 해야하고 출력시 print를 사용 실행 결과 테스트 1 입력값 〉 3 기댓값 〉 "Odd" 실행 결과 〉 테스트를 통과하였습니다. 테스트 2 입력값 〉 4 기댓값 〉 "Even" 실행 결과 〉 테스트를 통과하였습니다. 테스트 결과 (~˘˘)~ 2개 중 2개 성공
문제 설명 정수를 담고 있는 배열 arr의 평균값을 return하는 함수, solution을 완성해보세요. 제한사항 arr은 길이 1 이상, 100 이하인 배열입니다. arr의 원소는 -10,000 이상 10,000 이하인 정수입니다. 입출력 예 arr return [1,2,3,4] 2.5 [5,5] 5 정답 def solution(arr): answer = sum(arr)/len(arr) return answer 실행 결과 테스트 1 입력값 〉 [1, 2, 3, 4] 기댓값 〉 2.5 실행 결과 〉 테스트를 통과하였습니다. 테스트 2 입력값 〉 [5, 5] 기댓값 〉 5.0 실행 결과 〉 테스트를 통과하였습니다. 테스트 결과 (~˘˘)~ 2개 중 2개 성공
첨부파일 A1팀 보고서.docx 파일 다운로드 첨부파일 A1_SJH.py 파일 다운로드 # 0920_covid SJH import numpy as np import pandas as pd text = pd.read_csv(r'C:\Users\tj-bu\PycharmProjects\pythonProject\csse_covid_19_daily_reports\12-31-2020.csv') textt = pd.read_csv(r'C:\Users\tj-bu\PycharmProjects\pythonProject\csse_covid_19_daily_reports\12-31-2021.csv') text1 = text.groupby('Country_Region')['Confirmed', 'Deaths', 'Recovered', 'Active'].sum() textt1 = textt.groupby('Country_Region')['Confirmed', 'Deaths', 'Recovered', 'Act
첨부파일 7.pdf 파일 다운로드
첨부파일 8.pdf 파일 다운로드 첨부파일 9.pdf 파일 다운로드
첨부파일 R 문제 _신정훈.R 파일 다운로드 # 신정훈 # [문항1] * 아래 문제를 R code로 작성하여 제출하시오. # 다음은 학생별 과목별 시험 점수이다. Data를 대상으로 # 데이터프레임을 생성하고, 그 데이터프레임을 사용하고apply()를 # 적용하여 행/열 방향으로 조건에 맞게 통계량을 구하시오. library(dplyr) # 1) 3명 의사의 과목점수를 이용하여 데이터프레임(DataFrame)을 # 생성하여 화면출력하시오. Yoon <- c(95,83,75) Ahn <- c(85,95,60) Lee <- c(70,80,95) Data <- data.frame(Yoon,Ahn,Lee) rownames(Data) <- c('국어(Kor)','영어(Eng)','수학(Mat)') colnames(Data) <- c('윤봉길(Yoon)','안중근(Ahn)','이봉창(Lee)') Data apply(Data[3,],1,mean) # 3) 윤봉길의사의 과목 평균점수를 구하시오.
첨부파일 0927_training.R 파일 다운로드 # 0927_training # 1.8 집단변수 대상 그룹화 # 데이터 셋 내 범주형 컬럼을 대상으로 그룹화하는 group_by()함수 사용 # 형식: group_by(dataframe, 집단변수) # group_by 함수에 객체를 지정하면 컬럼별로 분리한다. # 컬럼의 집단별 평균 요약 통계량 # 컬럼의 집단별 평균에 대한 요약 통계량을 반환한다. # Ex. library(dplyr) csvgrade <- read.csv("grade_csv.csv") csvgrade %>% group_by(class) %>% summarise(mean_math = mean(math)) # group_by 함수는 인자로 범주형 변수가 포함된 컬럼명을 인자로 받아 요약 통계량을 # 계산 # 컬럼의 집단별 다중 요약 통계량 # 컬럼의 집단별 다중 요약 통계량을 반환한다. # Ex. library(dplyr) csvgrade <- read.csv("gr
첨부파일 0928_training.R 파일 다운로드 # Ch7 EDA와 data정제 # 데이터 전처리(data preprocessing) 과정 # 1. EDA란? # 탐색적 자료분석(Exploratory Data Analysis): # - 수집한 자료를 다양한 각도에서 관찰하고 이해하는 과정 # - 그래프나 통계적 방법을 이용하여 자료를 직관적으로 파악하는 과정 # 1.1 EDA 필요성 # 자료의 분포와 통계 파악 자료의 특성 이해 # 잠재적인 문제 발견 기존의 가설 수정 또는 새로운 방향의 가설 설정 # 1.2 EDA 과정 # 단계별 EDA 수행과정 # 1. 분석의 목적과 변수의 특징 확인 # 2. 자료 확인 및 전처리: 결측치, 이상치 # 3. 자료의 각 변수 관찰: 통계조사, 시각화 # 4. 변수 간의 관계에 초점을 맞춰 패턴 발견: 상관관계, 시각화 도구로 변수간의 패턴 발 # 견 # 2. 수집자료 이해 # 수집된 자료를 이해하는 단계 # 예) 자료구조, 관측치의 길이,
첨부파일 1.pdf 파일 다운로드 첨부파일 2.pdf 파일 다운로드 첨부파일 3.pdf 파일 다운로드 첨부파일 4.pdf 파일 다운로드 첨부파일 5.pdf 파일 다운로드 첨부파일 6.pdf 파일 다운로드
첨부파일 0922_training.R 파일 다운로드 rm(list=is()) ch.2 데이터 유형과 구조 R에서 제공하는 자료구조 1) Vector (1차원 배열) 2) Matrix (2차원 배열) 3) Array (다차원 배열) 4) Data Frame (2차원 테이블 구조) 5) List (자료구조 중첩) 1. Vector자료구조 index로 접근 가능 1.1 벡터 객체 벡터데이터 생성: c(), seq(), rep()함수 이용 c()함수 인수는 콜론(:)이나 콤마(,)를 이용하여 표현 콜론(:): 범위 콤마(,): 개별 데이터 구분 실습 (c()함수 이용 벡터 생성) c()함수 https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/c # 실습: c() 함수를 이용한 벡터 객체 생성 c(1:20) 1:20 c(1, 2, 3, 4, 5) 실습 (seq()함수 이용 벡터 생성) seq()함수 https://www.rd
첨부파일 0923_training.R 파일 다운로드 # 0923_taraining # Ch03 데이터 입출력 # 1. 데이터 불러오기 # 1.1 키보드 입력 # scan()함수, edit()함수 # (1) scan()함수 이용 # 실습 (키보드로 숫자 입력) # scan() 함수를 실행하면 console창에 입력 데이터의 순서를 나타내는 프롬프트가 표시 # 입력된 데이터는 입력된 순서대로 벡터변수에 저장됨 num <- scan() num sum(num) # 실습 (키보드로 문자 입력) # 키보드로 문자 입력을 위해서 scan()함수에서 ‘what=character()’를 사용 name <- scan(what = character()) name # (2) edit() 함수를 이용한 입력 # edit()함수는 표 형식의 데이터편집기를 제공 # 실습 (편집기를 이용한 data.frame 만들기) df = data.frame() df = edit(df) df # * Mac에서는 미동작 #
# 09226_t# 09226_training # 4.5 몬테카를로 시뮬레이션 함수 정의 # 몬테카를로 시뮬레이션은 현실적으로 불가능한 문제의 해답을 얻기 위해 난수의 확률 # 분포를 이용하는 모의 시험으로 근사적 해를 구하는 기법 # 실습 (동전 앞면과 뒷면에 대한 난수 확률분포의 기대확률 모의시험) # 동전 앞면과 뒷면의 난수 확률분포 함수 정의 coin <- function(n) { r <- runif(n, min = 0, max = 1) result <- numeric() for(i in 1:n) { if(r[i] <= 0.5) result[i] <- 0 else result[i] <- 1 } return(result) } # 동전 던지기 횟수가 10회인 경우 앞면(0)과 뒷면(1)이 나오는 vector 값 coin(10) # 몬테카를로 시뮬레이션 함수 정의 montaCoin <- function(n) { cnt <- 0 for(i in 1:n) { cnt <- cnt + c
# 0919_training # pandas import numpy as np import pandas as pd ''' fillna 메서드를 사용해서 누락된 값을 채우는 것은 값 치환 작업이라 볼 수 있음 map 메서드는 한 객체 안에서 값의 부분집합을 변경하는데 사용 ''' # replace 메서드는 같은 작업을 간단하고 유연한 방법 제공 data = pd.Series([1., -999., 2., -999., -1000., 3.]) data # -999 는 누락된 데이터를 나타내기 위한 값 # replace 메서드를 이용하여 NA 값으로 치환한 새로운 Series 생성 data.replace(-999, np.nan) # 여러 개의 값을 한 번에 치환하려면 하나의 값 대신 치환하려는 값의 리스트 사용 data.replace([-999, -1000], np.nan) # 치환하려는 값마다 다른 값으로 치환하려면 누락된 값 대신 새로 지정할 값의 리스트 사용 data.replace([-
# 0920_training import pandas as pd import numpy as np # 10.1.3 Grouping with Dicts and Series # 그룹 정보는 배열이 아닌 형태로 존재하기도 한다. # DataFrame 예제 people = pd.DataFrame(np.random.randn(5, 5), columns=['a', 'b', 'c', 'd', 'e'], index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis']) people.iloc[2:3, [1, 2]] = np.nan # Add a few NA values people # 각 컬럼을 나타낼 그룹 목록이 있고 그룹별로 컬럼의 값을 모두 더하는 경우 mapping = {'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'blue', 'e': 'red', 'f' : 'orange'} # dict 에서 groupby 메서드로 배열을 추출할 수 있지만
# 0921_raining a <- 5 a <- 5 b <- 10 a <- 10 #사용설명 print(a,b) dim(available.packages()) a <- available.packages() head(a) install.packages("stringr") library(stringr) remove.packages("stringr") data() # 기본데이 셋 보기 hist(Nile) hist(Nile,freq = F) lines(density(Nile)) #working directory getwd() setwd('c:/users/tj-bu/Documents') getwd() # 변수이름 명명 방법 # (1) 변수 이름 명명 규칙 in R # 1) 첫 글자는 영문자로 시작 # 2) 2 번째 단어부터는 숫자, _, . 등을 사용 가능 # 3) 대문자와 소문자를 구별한다. # 4) 변수의 이름은 의미에 맞도록 작성한다. # 5) 한 번 정의된 변수는 재사용이 가능하고, 가
첨부파일 0916_training.py 파일 다운로드 # 0916_training # pandas # pandas 객체에 Numpy 의 유니버설 함수(배열의 각 원소에 적용되는 메서드) 적용 가능 import pandas as pd import numpy as np frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon']) frame np.abs(frame) # 자주 사용되는 또 다른 연산은 각 컬럼이나 로우의 1 차원 배열에 함수를 적용하는 것 # DataFrame 의 apply 메서드 사용 f = lambda x: x.max() - x.min() # 최대값 - 최소값 frame.apply(f) # apply 함수에 axis = 'columns' 설정시 각 로우에 대해 한 번씩만 수행 frame.apply(f, axis='columns') # 배열에
# 0915_training # Numpy import numpy as np # --> '벡터화' : 같은 크기의 배열 간의 산술 연산은 배열의 각 원소 단위로 적용 arr = np.array([[1., 2., 3.], [4., 5., 6.]]) arr arr * arr arr - arr # 스칼라 인자가 포함된 산술 연산의 경우 배열 내의 모든 원소에 스칼라 인자가 적용된다. 1 / arr arr ** 0.5 # 같은 크기를 가지는 배열 간의 비교 연산은 불리언 배열을 반환 arr2 = np.array([[0., 4., 1.], [7., 2., 12.]]) arr2 arr2 > arr # 브로드캐스팅(broadcasting): 크기가 다른 배열 간의 연 arr = np.arange(10) arr arr[5] arr[5:8] arr[5:8] = 12 arr # arr 배열의 슬라이스 생성 arr_slice = arr[5:8] arr_slice # arr_slice 의 값을 변경하면
# 0915_training # pandas import pandas as pd # Series 와 DataFrame 은 로컬 네임스페이스로 인포트 from pandas import Series, DataFrame # 환경설정 import numpy as np np.random.seed(12345) import matplotlib.pyplot as plt # DataFrame 객체 생성 # 같은 길이의 리스트에 담긴 사전을 이용하거나 NumPy 배열을 이용 data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, 2002, 2003], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]} frame = pd.DataFrame(data) # 만들어진 DataFrame 의 색인은 Series 와 같은 방식으로 자동으로 대입되며 컬럼은 정렬되
첨부파일 0908_training.py 파일 다운로드 # 0908_training # 제 7장 연습문제 #1. 아이디 :첫자는 영문소문자, 단어길이 4자 이상 #2. 호스트이름 : 영문 소문자 시작, 단어길이 3자이상 #3. 최상위 도메인 : 영문소문자 3자리 이하 #4. 정규표현식 기본 패텅 : '메타문자@메타문자.메타문자 email = """[email protected] [email protected] [email protected] [email protected]""" from re import findall, match for e in email.split(sep='\n') : p = match(r'[a-z][a-zA-Z0-9]{3,}[@]\w{3,}[.]\w{0,3}',e) if p : print(e) #Q2 from re import findall emp = ["2014홍길동220","2002이순신","2010유관순260"] #함수정의 def name_pro(emp): text = find
# 0913-training # os.path 모듈관련 함수 import os.path import output as output os. getcwd() os.chdir('ch8_data') os.getcwd() os.path.abspath('lecture/step01_try_except.py') os.path.dirname('lecture/step01_try_except.py') os.path.exists('c:\\Users\\tj-bu\\PycharmProjects\\pythonProject') os.path.isfile('lecture/step01_try_except.py') os.path.isdir('lecture') os.path.split("c:\\test\\test1.txt") os.path.join('c\\test','test1.txt') os.path.getsize('lecture/txt.py') # 텍스트 자료수집 import os print(os.getcwd())
# 0905_training # 재귀함수 정의 : 1~n Counter = [] def Counter(n): if n == 0 : return 0 else : a = Counter(n-1) print(n,end=' ') print('n=',Counter(0)) print(Counter(5)) # 재귀함수 정의 : 1~n 누적합 def Adder(n): if n ==1 : return 1 else: result= n + Adder(n-1) print(n,end=' ') return result print('n=1 :',Adder(1)) print('\nn=5',Adder(5)) #=========================================================== # 문제 Q1 def StarCount(height) : if height == 1 : print(height*'*') return 1 else : result = height + StarCount(he
첨부파일 0906_training.py 파일 다운로드 # 0906_training # 생성자(현잔고, 입금액, 출금액) # method 1개 현잔고, 입금액, 출금액을 계산하여 업데이트된 잔고를 계산 # 현잔고 : 10,000원, 입금액 : 5,000원, 출금액 : 8,000원 # 업데이트된 잔고를 프린트 하세요. class account : def __init__(self, balance, inposit, whithdraw): self.balance = balance self.inposit = inposit self.whithdraw = whithdraw def display(self): display = self.balance + self. inposit - self.whithdraw return display bal = account(10000, 5000, 8000) new = bal.display() print(new) # 현재잔고와 sqrt값을 조회하는 클래스를 정의하세요
첨부파일 0907_training.py 파일 다운로드 # 0907_training # 복습 list = [1,2,3,4,5] *v1,v2=list print(v1, v2) print("실수 반환 ", format(3.1,"3.2f")) print("정수 소수점 반환", format(3345,",d")) name = '나나나' age = 32 ki = 13.222 print("이름 : %s, 나이 : %d, ki : %.2f"%(name,age,ki)) print("{0}, {2}, {1}".format(name,age,ki)) # 문자열 찾기 import re from re import findall st1 = '1234 abc홍길동 ABC_15523235_6 이다도시' print(findall('1234', st1)) print(findall('[0-9]',st1)) print(findall('[0-9]{3}',st1)) print(findall('[0-9]{3,}',st1)) p
# 0902_training. # abs(x) abs(10) abs(-10) abs(-123.45) # all(iterable) all([1,True, 10,-15.2]) all([1,True,0,-15.2]) all([1,False,0,-15.2]) #any(iterable) any(([1,False,0,15.2])) any([False,0,0]) #bin(number) bin(10) bin(15) #dir(x) x=[1,2,3,4,5] dir(x) x.append(6) print(x) #eval(expr) eval("2+10") eval(10 + "20*30") eval("20*30")+10 # hex(numbers) hex(10) hex(15) hex(64) #oct(number) oct(10) oct(7) oct(8) #ord(charactor) ord('0') ord('8') ord('a') #pow(x,y) pow('a',5) pow(10,3) pow(10,3) pow(1