'Python 파이썬'에 해당되는 글 22건
- 2021.07.11 :: 파이썬 리스트에 있는 값들의 모든 조합구하기
- 2021.06.18 :: K리그 축구 승부 예측 프로그램 (Python 부분) 1
- 2019.11.21 :: [파이썬, 텐서플로우] 단순회귀분석 (Simple Regression Analysis) 2
- 2019.11.21 :: [파이썬] 상관분석 (Correlation Analysis)
- 2019.11.12 :: 군집 분석 (클러스터 분석)
- 2019.11.11 :: K-최근접 이웃 알고리즘 (KNN) 간단한 파이썬 코드
- 2019.11.11 :: K-최근접 이웃 알고리즘 (KNN)
- 2019.11.06 :: 범주형 데이터 선형회귀 분석하기 2
하나의 리스트에 있는 값들의 모든 조합구하기
from itertools import combinations // itertools 라이브러리에 있는 combinations 불러오기
x = [1,2,3,4] // 리스트 제작
list(combinations(x,2)) // 리스트의 값들을 2개씩 묶은 모든 조합 구하기
여러 리스트에 있는 값들의 모든 조합 구하기
from itertools import product // itertools 라이브러리에 있는 combinations 불러오기
x = [(1,2,3),(4,5,6),('a','b','c')]
list(product(*x))
'Python 파이썬' 카테고리의 다른 글
| K리그 축구 승부 예측 프로그램 (Python 부분) (1) | 2021.06.18 |
|---|---|
| [파이썬] 상관분석 (Correlation Analysis) (0) | 2019.11.21 |
| [파이썬] 문자열 서식 (0) | 2019.10.09 |
| [파이썬] 간단한 팩토리얼 계산기 (0) | 2019.10.09 |
| [파이썬] 숫자야구게임 만들기 (0) | 2019.10.09 |
예전에 진행했던 https://sno-machinelearning.tistory.com/52?category=858218 의 Python 코드입니다.
다른 프로그램 코드는 제가 작성한 것이 아니라서 올리지 않겠습니다.
밑에 있는 코드는 여태까지(그때 기준으로요...) 있었던 경기의 결과로 각 팀들이 홈팀과 원정팀을 갔을 때 어떤 요인이 골에 영향이 가는지 정하고 새로운 홈팀과 원정팀에 대한 득점수를 예측하여 경기를 누가 이길 확률이 높은지 계산하는 코드입니다.
if a==1:
# 필요 패키지 다운로드
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import matplotlib.ticker as plticker
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import os
import tensorflow as tf
import statsmodels.formula.api as sm
from patsy import dmatrices
import pymysql #pip install PyMySQL
# 2019년 제외 DB 불러오기
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = "select * from not2019"
curs.execute(sql)
rows = curs.fetchall()
# Connection 닫기
conn.close()
# df로 변경
not2019 = pd.DataFrame(list(rows),columns=['K_NUMBER','K_DAY','HOME','AWAY',\
'HOME_GOAL','AWAY_GOAL','HOME_SHOT','AWAY_SHOT',\
'HOME_TSHOT','AWAY_TSHOT','HOME_PASHOT',\
'AWAY_PASHOT','HOME_PATSHOT','AWAY_PATSHOT',\
'HOME_DRB','AWAY_DRB','HOME_FSIN','AWAY_FSIN',\
'HOME_PASS','AWAY_PASS','HOME_KPASS','AWAY_KPASS'\
,'HOME_FPASS','AWAY_FPASS','HOME_BPASS',\
'AWAY_BPASS','HOME_LPASS','AWAY_LPASS',\
'HOME_CROSS','AWAY_CROSS','HOME_PASSSU',\
'AWAY_PASSSU','HOME_BATGRD','AWAY_BATGRD',\
'HOME_BATAIR','AWAY_BATAIR','HOME_TACK',\
'AWAY_TACK','HOME_INTERSEP','AWAY_INTERSEP',\
'HOME_FOUL','AWAY_FOUL','HOME_YLLCARD',\
'AWAY_YLLCARD','HOME_REDCARD','AWAY_REDCARD'])
# 필요없는 변수 제거 제거
not2019.drop('K_NUMBER',axis=1, inplace = True)
not2019.drop('K_DAY',axis=1, inplace = True)
not2019.drop('HOME_GOAL',axis=1, inplace = True)
not2019.drop('AWAY_GOAL',axis=1, inplace = True)
# 데이터 형식 변경
not2019.HOME_SHOT=pd.to_numeric(not2019.HOME_SHOT)
not2019.AWAY_SHOT=pd.to_numeric(not2019.AWAY_SHOT)
not2019.HOME_TSHOT=pd.to_numeric(not2019.HOME_TSHOT)
not2019.AWAY_TSHOT=pd.to_numeric(not2019.AWAY_TSHOT)
not2019.HOME_PASHOT=pd.to_numeric(not2019.HOME_PASHOT)
not2019.AWAY_PASHOT=pd.to_numeric(not2019.AWAY_PASHOT)
not2019.HOME_PATSHOT=pd.to_numeric(not2019.HOME_PATSHOT)
not2019.AWAY_PATSHOT=pd.to_numeric(not2019.AWAY_PATSHOT)
not2019.HOME_DRB=pd.to_numeric(not2019.HOME_DRB)
not2019.AWAY_DRB=pd.to_numeric(not2019.AWAY_DRB)
not2019.HOME_FSIN=pd.to_numeric(not2019.HOME_FSIN)
not2019.AWAY_FSIN=pd.to_numeric(not2019.AWAY_FSIN)
not2019.HOME_PASS=pd.to_numeric(not2019.HOME_PASS)
not2019.AWAY_PASS=pd.to_numeric(not2019.AWAY_PASS)
not2019.HOME_KPASS=pd.to_numeric(not2019.HOME_KPASS)
not2019.AWAY_KPASS=pd.to_numeric(not2019.AWAY_KPASS)
not2019.HOME_FPASS=pd.to_numeric(not2019.HOME_FPASS)
not2019.AWAY_FPASS=pd.to_numeric(not2019.AWAY_FPASS)
not2019.HOME_BPASS=pd.to_numeric(not2019.HOME_BPASS)
not2019.AWAY_BPASS=pd.to_numeric(not2019.AWAY_BPASS)
not2019.HOME_LPASS=pd.to_numeric(not2019.HOME_LPASS)
not2019.AWAY_LPASS=pd.to_numeric(not2019.AWAY_LPASS)
not2019.HOME_CROSS=pd.to_numeric(not2019.HOME_CROSS)
not2019.AWAY_CROSS=pd.to_numeric(not2019.AWAY_CROSS)
not2019.HOME_PASSSU=pd.to_numeric(not2019.HOME_PASSSU)
not2019.AWAY_PASSSU=pd.to_numeric(not2019.AWAY_PASSSU)
not2019.HOME_BATGRD=pd.to_numeric(not2019.HOME_BATGRD)
not2019.AWAY_BATGRD=pd.to_numeric(not2019.AWAY_BATGRD)
not2019.HOME_BATAIR=pd.to_numeric(not2019.HOME_BATAIR)
not2019.AWAY_BATAIR=pd.to_numeric(not2019.AWAY_BATAIR)
not2019.HOME_TACK=pd.to_numeric(not2019.HOME_TACK)
not2019.AWAY_TACK=pd.to_numeric(not2019.AWAY_TACK)
not2019.HOME_INTERSEP=pd.to_numeric(not2019.HOME_INTERSEP)
not2019.AWAY_INTERSEP=pd.to_numeric(not2019.AWAY_INTERSEP)
not2019.HOME_FOUL=pd.to_numeric(not2019.HOME_FOUL)
not2019.AWAY_FOUL=pd.to_numeric(not2019.AWAY_FOUL)
not2019.HOME_YLLCARD=pd.to_numeric(not2019.HOME_YLLCARD)
not2019.AWAY_YLLCARD=pd.to_numeric(not2019.AWAY_YLLCARD)
not2019.HOME_REDCARD=pd.to_numeric(not2019.HOME_REDCARD)
not2019.AWAY_REDCARD=pd.to_numeric(not2019.AWAY_REDCARD)
## 홈 PA 유효슈팅 구하기
## 다중 선형 회귀 분석 (Multiple regression)
# 홈 PA샷의 상관계수표
corr = not2019.corr(method = 'pearson')
# 홈 PATSHOT의 선형회귀표 (모든 변수들을 넣은 상태에서 변수선택법 중 후진제거법을 사용)
model = sm.ols(formula = 'HOME_PATSHOT ~ HOME_SHOT + HOME_TSHOT + HOME_PASHOT + HOME_DRB + HOME_KPASS',data=not2019).fit()
#model.summary()
# 선택된 변수들을 메트릭스 표로 변경
multi_y = np.array(not2019.HOME_PATSHOT)
df_x = not2019[["HOME_SHOT", "HOME_TSHOT", "HOME_PASHOT", "HOME_DRB" , "HOME_KPASS"]]
multi_x = df_x.as_matrix()
# 모델 틀 설계
with tf.Graph().as_default() as multi_regresstion:
num_x = 5
X = tf.placeholder(tf.float32, [None, num_x], name='X')
Y = tf.placeholder(tf.float32, [None], name='Y')
lr = tf.constant(1e-3,tf.float32)
W = tf.get_variable("W", [1,num_x], tf.float32)
b = tf.get_variable("b",dtype=tf.float32,initializer=tf.constant(1.,tf.float32))
h = tf.matmul(W,X,transpose_b=True) + b
cost = tf.reduce_mean(tf.square(tf.subtract(h,Y)))
train = tf.train.GradientDescentOptimizer(lr).minimize(cost)
# 모델 틀에 메트릭스를 넣음
with tf.Session(graph=multi_regresstion) as sess:
sess.run(tf.global_variables_initializer())
for i in range(3000):
_,l = sess.run([train,cost],feed_dict={X:multi_x,Y:multi_y})
W_multi, b_multi = sess.run([W,b])
# 계수 구하기
for j in range(len(multi_x)):
sum = 0
for i in range(5):
sum += W_multi[0][i] * multi_x[j,i]
# 홈 PA유효슈팅 계수 저장
HOME_W_multi,HOME_b_multi = W_multi,b_multi
## 어웨이 PA 유효슈팅 구하기
# 어웨이 선형회귀표(변수선택법 = 후진제거법)
Away_model = sm.ols(formula = 'AWAY_PATSHOT ~ AWAY_SHOT + AWAY_TSHOT + AWAY_PASHOT + AWAY_DRB + AWAY_KPASS',data=not2019).fit()
multi_y = np.array(not2019.AWAY_PATSHOT)
df_x = not2019[["AWAY_SHOT", "AWAY_TSHOT", "AWAY_PASHOT", "AWAY_DRB" , "AWAY_KPASS"]]
multi_x = df_x.as_matrix()
with tf.Graph().as_default() as multi_regresstion:
num_x = 5
X = tf.placeholder(tf.float32, [None, num_x], name='X')
Y = tf.placeholder(tf.float32, [None], name='Y')
lr = tf.constant(1e-3,tf.float32)
W = tf.get_variable("W", [1,num_x], tf.float32)
b = tf.get_variable("b",dtype=tf.float32,initializer=tf.constant(1.,tf.float32))
h = tf.matmul(W,X,transpose_b=True) + b
cost = tf.reduce_mean(tf.square(tf.subtract(h,Y)))
train = tf.train.GradientDescentOptimizer(lr).minimize(cost)
with tf.Session(graph=multi_regresstion) as sess:
sess.run(tf.global_variables_initializer())
for i in range(3000):
_,l = sess.run([train,cost],feed_dict={X:multi_x,Y:multi_y})
W_multi, b_multi = sess.run([W,b])
for j in range(len(multi_x)):
sum = 0
for i in range(5):
sum += W_multi[0][i] * multi_x[j,i]
# 어웨이 PA유효슈팅 계수
AWAY_W_multi,AWAY_b_multi = W_multi,b_multi
## 새로운 데이터 예측
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = "select * from rawdb"
curs.execute(sql)
rowdata = curs.fetchall()
if rowdata != ():
sql = "DELETE FROM rawdb WHERE K_NUMBER = '%s'" % '0'
curs.execute(sql)
conn.commit()
# Connection 닫기
conn.close()
try:
if rowdata != ():
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = "select * from kleague" # 경기 번호불러오기 위한 데이터
curs.execute(sql)
raw = curs.fetchall()
num = (int(raw[-1][0]))+1
except:
rowdata = ()
# rowdf 만들기
try:
if rowdata != ():
rowdf1 = pd.DataFrame(list(rowdata),columns=['K_NUMBER','K_DAY','HOME','AWAY',\
'HOME_GOAL','AWAY_GOAL','HOME_SHOT','AWAY_SHOT',\
'HOME_TSHOT','AWAY_TSHOT','HOME_PASHOT',\
'AWAY_PASHOT','HOME_PATSHOT','AWAY_PATSHOT',\
'HOME_DRB','AWAY_DRB','HOME_FSIN','AWAY_FSIN',\
'HOME_PASS','AWAY_PASS','HOME_KPASS','AWAY_KPASS'\
,'HOME_FPASS','AWAY_FPASS','HOME_BPASS',\
'AWAY_BPASS','HOME_LPASS','AWAY_LPASS',\
'HOME_CROSS','AWAY_CROSS','HOME_PASSSU',\
'AWAY_PASSSU','HOME_BATGRD','AWAY_BATGRD',\
'HOME_BATAIR','AWAY_BATAIR','HOME_TACK',\
'AWAY_TACK','HOME_INTERSEP','AWAY_INTERSEP',\
'HOME_FOUL','AWAY_FOUL','HOME_YLLCARD',\
'AWAY_YLLCARD','HOME_REDCARD','AWAY_REDCARD'])
rowdf = rowdf1[0:1]
except:
rowdata = ()
try:
if rowdata != ():
rowdf['K_NUMBER'] = num
rowdf['K_DAY'] = rowdf['K_DAY'].astype(object)
rowdf['HOME'] = rowdf['HOME'].astype(object)
rowdf['AWAY'] = rowdf['AWAY'].astype(object)
rowdf.HOME_GOAL=pd.to_numeric(rowdf.HOME_GOAL)
rowdf.AWAY_GOAL=pd.to_numeric(rowdf.AWAY_GOAL)
rowdf.HOME_SHOT=pd.to_numeric(rowdf.HOME_SHOT)
rowdf.AWAY_SHOT=pd.to_numeric(rowdf.AWAY_SHOT)
rowdf.HOME_TSHOT=pd.to_numeric(rowdf.HOME_TSHOT)
rowdf.AWAY_TSHOT=pd.to_numeric(rowdf.AWAY_TSHOT)
rowdf.HOME_PASHOT=pd.to_numeric(rowdf.HOME_PASHOT)
rowdf.AWAY_PASHOT=pd.to_numeric(rowdf.AWAY_PASHOT)
rowdf.HOME_PATSHOT=pd.to_numeric(rowdf.HOME_PATSHOT)
rowdf.AWAY_PATSHOT=pd.to_numeric(rowdf.AWAY_PATSHOT)
rowdf.HOME_DRB=pd.to_numeric(rowdf.HOME_DRB)
rowdf.AWAY_DRB=pd.to_numeric(rowdf.AWAY_DRB)
rowdf.HOME_FSIN=pd.to_numeric(rowdf.HOME_FSIN)
rowdf.AWAY_FSIN=pd.to_numeric(rowdf.AWAY_FSIN)
rowdf.HOME_PASS=pd.to_numeric(rowdf.HOME_PASS)
rowdf.AWAY_PASS=pd.to_numeric(rowdf.AWAY_PASS)
rowdf.HOME_KPASS=pd.to_numeric(rowdf.HOME_KPASS)
rowdf.AWAY_KPASS=pd.to_numeric(rowdf.AWAY_KPASS)
rowdf.HOME_FPASS=pd.to_numeric(rowdf.HOME_FPASS)
rowdf.AWAY_FPASS=pd.to_numeric(rowdf.AWAY_FPASS)
rowdf.HOME_BPASS=pd.to_numeric(rowdf.HOME_BPASS)
rowdf.AWAY_BPASS=pd.to_numeric(rowdf.AWAY_BPASS)
rowdf.HOME_LPASS=pd.to_numeric(rowdf.HOME_LPASS)
rowdf.AWAY_LPASS=pd.to_numeric(rowdf.AWAY_LPASS)
rowdf.HOME_CROSS=pd.to_numeric(rowdf.HOME_CROSS)
rowdf.AWAY_CROSS=pd.to_numeric(rowdf.AWAY_CROSS)
rowdf.HOME_PASSSU=pd.to_numeric(rowdf.HOME_PASSSU)
rowdf.AWAY_PASSSU=pd.to_numeric(rowdf.AWAY_PASSSU)
rowdf.HOME_BATGRD=pd.to_numeric(rowdf.HOME_BATGRD)
rowdf.AWAY_BATGRD=pd.to_numeric(rowdf.AWAY_BATGRD)
rowdf.HOME_BATAIR=pd.to_numeric(rowdf.HOME_BATAIR)
rowdf.AWAY_BATAIR=pd.to_numeric(rowdf.AWAY_BATAIR)
rowdf.HOME_TACK=pd.to_numeric(rowdf.HOME_TACK)
rowdf.AWAY_TACK=pd.to_numeric(rowdf.AWAY_TACK)
rowdf.HOME_INTERSEP=pd.to_numeric(rowdf.HOME_INTERSEP)
rowdf.AWAY_INTERSEP=pd.to_numeric(rowdf.AWAY_INTERSEP)
rowdf.HOME_FOUL=pd.to_numeric(rowdf.HOME_FOUL)
rowdf.AWAY_FOUL=pd.to_numeric(rowdf.AWAY_FOUL)
rowdf.HOME_YLLCARD=pd.to_numeric(rowdf.HOME_YLLCARD)
rowdf.AWAY_YLLCARD=pd.to_numeric(rowdf.AWAY_YLLCARD)
rowdf.HOME_REDCARD=pd.to_numeric(rowdf.HOME_REDCARD)
rowdf.AWAY_REDCARD=pd.to_numeric(rowdf.AWAY_REDCARD)
except:
rowdata = ()
if rowdata != ():
rowdf.HOME_PATSHOT = HOME_W_multi[0][0]*rowdf.HOME_SHOT+HOME_W_multi[0][1]*rowdf.HOME_TSHOT+\
HOME_W_multi[0][2]*rowdf.HOME_PASHOT+HOME_W_multi[0][3]*rowdf.HOME_DRB+HOME_W_multi[0][4]*\
rowdf.HOME_KPASS+HOME_b_multi
rowdf["HOME_PATSHOT"] = rowdf["HOME_PATSHOT"].astype(int)
rowdf.AWAY_PATSHOT = AWAY_W_multi[0][0]*rowdf.AWAY_SHOT+AWAY_W_multi[0][1]*rowdf.AWAY_TSHOT+\
AWAY_W_multi[0][2]*rowdf.AWAY_PASHOT+AWAY_W_multi[0][3]*rowdf.AWAY_DRB+AWAY_W_multi[0][4]*\
rowdf.AWAY_KPASS+AWAY_b_multi
rowdf["AWAY_PATSHOT"] = rowdf["AWAY_PATSHOT"].astype(int)
for i in range(len(rowdf.HOME_PATSHOT)):
if rowdf.HOME_PATSHOT[i]>min(rowdf.HOME_TSHOT[i],rowdf.HOME_PASHOT[i]):
rowdf.HOME_PATSHOT[i]=min(rowdf.HOME_TSHOT[i],rowdf.HOME_PASHOT[i])
for i in range(len(rowdf.AWAY_PATSHOT)):
if rowdf.AWAY_PATSHOT[i]>min(rowdf.AWAY_TSHOT[i],rowdf.AWAY_PASHOT[i]):
rowdf.AWAY_PATSHOT[i]=min(rowdf.AWAY_TSHOT[i],rowdf.AWAY_PASHOT[i])
datarow = pd.DataFrame(rowdf)
if rowdata != ():
rowdf['K_NUMBER'] = rowdf['K_NUMBER'].astype(str)
rowdf['K_DAY'] = rowdf['K_DAY'].astype(str)
rowdf['HOME'] = rowdf['HOME'].astype(str)
rowdf['AWAY'] = rowdf['AWAY'].astype(str)
rowdf['HOME_GOAL'] = rowdf['HOME_GOAL'].astype(str)
rowdf['AWAY_GOAL'] = rowdf['AWAY_GOAL'].astype(str)
rowdf['HOME_SHOT'] = rowdf['HOME_SHOT'].astype(str)
rowdf['AWAY_SHOT'] = rowdf['AWAY_SHOT'].astype(str)
rowdf['HOME_TSHOT'] = rowdf['HOME_TSHOT'].astype(str)
rowdf['AWAY_TSHOT'] = rowdf['AWAY_TSHOT'].astype(str)
rowdf['HOME_PASHOT'] = rowdf['HOME_PASHOT'].astype(str)
rowdf['AWAY_PASHOT'] = rowdf['AWAY_PASHOT'].astype(str)
rowdf['HOME_PATSHOT'] = rowdf['HOME_PATSHOT'].astype(str)
rowdf['AWAY_PATSHOT'] = rowdf['AWAY_PATSHOT'].astype(str)
rowdf['HOME_DRB'] = rowdf['HOME_DRB'].astype(str)
rowdf['AWAY_DRB'] = rowdf['AWAY_DRB'].astype(str)
rowdf['HOME_FSIN'] = rowdf['HOME_FSIN'].astype(str)
rowdf['AWAY_FSIN'] = rowdf['AWAY_FSIN'].astype(str)
rowdf['HOME_PASS'] = rowdf['HOME_PASS'].astype(str)
rowdf['AWAY_PASS'] = rowdf['AWAY_PASS'].astype(str)
rowdf['HOME_KPASS'] = rowdf['HOME_KPASS'].astype(str)
rowdf['AWAY_KPASS'] = rowdf['AWAY_KPASS'].astype(str)
rowdf['HOME_FPASS'] = rowdf['HOME_FPASS'].astype(str)
rowdf['AWAY_FPASS'] = rowdf['AWAY_FPASS'].astype(str)
rowdf['HOME_BPASS'] = rowdf['HOME_BPASS'].astype(str)
rowdf['AWAY_BPASS'] = rowdf['AWAY_BPASS'].astype(str)
rowdf['HOME_LPASS'] = rowdf['HOME_LPASS'].astype(str)
rowdf['AWAY_LPASS'] = rowdf['AWAY_LPASS'].astype(str)
rowdf['HOME_CROSS'] = rowdf['HOME_CROSS'].astype(str)
rowdf['AWAY_CROSS'] = rowdf['AWAY_CROSS'].astype(str)
rowdf['HOME_PASSSU'] = rowdf['HOME_PASSSU'].astype(str)
rowdf['AWAY_PASSSU'] = rowdf['AWAY_PASSSU'].astype(str)
rowdf['HOME_BATGRD'] = rowdf['HOME_BATGRD'].astype(str)
rowdf['AWAY_BATGRD'] = rowdf['AWAY_BATGRD'].astype(str)
rowdf['HOME_BATAIR'] = rowdf['HOME_BATAIR'].astype(str)
rowdf['AWAY_BATAIR'] = rowdf['AWAY_BATAIR'].astype(str)
rowdf['HOME_TACK'] = rowdf['HOME_TACK'].astype(str)
rowdf['AWAY_TACK'] = rowdf['AWAY_TACK'].astype(str)
rowdf['HOME_INTERSEP'] = rowdf['HOME_INTERSEP'].astype(str)
rowdf['AWAY_INTERSEP'] = rowdf['AWAY_INTERSEP'].astype(str)
rowdf['HOME_FOUL'] = rowdf['HOME_FOUL'].astype(str)
rowdf['AWAY_FOUL'] = rowdf['AWAY_FOUL'].astype(str)
rowdf['HOME_YLLCARD'] = rowdf['HOME_YLLCARD'].astype(str)
rowdf['AWAY_YLLCARD'] = rowdf['AWAY_YLLCARD'].astype(str)
rowdf['HOME_REDCARD'] = rowdf['HOME_REDCARD'].astype(str)
rowdf['AWAY_REDCARD'] = rowdf['AWAY_REDCARD'].astype(str)
if rowdata != ():
li = np.array(rowdf)
li2 = li[0]
tu=""
for i in li2:
tu = tu + "'"+ i + "',"
if rowdata != ():
names = "K_NUMBER,K_DAY,HOME,AWAY,HOME_GOAL,AWAY_GOAL,HOME_SHOT,AWAY_SHOT,\
HOME_TSHOT,AWAY_TSHOT,HOME_PASHOT,AWAY_PASHOT,HOME_PATSHOT,AWAY_PATSHOT,\
HOME_DRB,AWAY_DRB,HOME_FSIN,AWAY_FSIN,HOME_PASS,AWAY_PASS,HOME_KPASS,AWAY_KPASS,\
HOME_FPASS,AWAY_FPASS,HOME_BPASS,AWAY_BPASS,HOME_LPASS,AWAY_LPASS,\
HOME_CROSS,AWAY_CROSS,HOME_PASSSU,AWAY_PASSSU,HOME_BATGRD,AWAY_BATGRD,\
HOME_BATAIR,AWAY_BATAIR,HOME_TACK,AWAY_TACK,HOME_INTERSEP,AWAY_INTERSEP,\
HOME_FOUL,AWAY_FOUL,HOME_YLLCARD,AWAY_YLLCARD,HOME_REDCARD,AWAY_REDCARD"
sqls= "INSERT INTO kleague ("+names+") VALUES ("+tu[:-1]+")"
# 만약 값이 여러개 들어가 있을 시
if rowdata != ():
if (len(rowdata)) > 1:
rowdf2 = rowdf1[1:]
rowdf2.K_NUMBER = rowdf2.K_NUMBER-1
for i in range(len(rowdf2.K_NUMBER)):
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql3= "UPDATE rawdb SET K_NUMBER='%s' WHERE K_NUMBER ='%s'" % (str((int(rowdata[i+1][0])-1)),str((int(rowdata[i+1][0]))))
curs.execute(sql3)
conn.commit()
conn.close()
if rowdata != ():
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = sqls
curs.execute(sql)
conn.commit()
# Connection 닫기
conn.close()
rowdata = ()
## 승부예측
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = "select * from kleague" #2019년 제외 DB 불러오기
curs.execute(sql)
k_raw = curs.fetchall()
# Connection 닫기
conn.close()
results = pd.DataFrame(list(k_raw),columns=['K_NUMBER','K_DAY','HOME','AWAY',\
'HOME_GOAL','AWAY_GOAL','HOME_SHOT','AWAY_SHOT',\
'HOME_TSHOT','AWAY_TSHOT','HOME_PASHOT',\
'AWAY_PASHOT','HOME_PATSHOT','AWAY_PATSHOT',\
'HOME_DRB','AWAY_DRB','HOME_FSIN','AWAY_FSIN',\
'HOME_PASS','AWAY_PASS','HOME_KPASS','AWAY_KPASS'\
,'HOME_FPASS','AWAY_FPASS','HOME_BPASS',\
'AWAY_BPASS','HOME_LPASS','AWAY_LPASS',\
'HOME_CROSS','AWAY_CROSS','HOME_PASSSU',\
'AWAY_PASSSU','HOME_BATGRD','AWAY_BATGRD',\
'HOME_BATAIR','AWAY_BATAIR','HOME_TACK',\
'AWAY_TACK','HOME_INTERSEP','AWAY_INTERSEP',\
'HOME_FOUL','AWAY_FOUL','HOME_YLLCARD',\
'AWAY_YLLCARD','HOME_REDCARD','AWAY_REDCARD'])
results['K_NUMBER'] = results['K_NUMBER'].astype(int)
results['K_DAY'] = results['K_DAY'].astype(object)
results['HOME'] = results['HOME'].astype(object)
results['AWAY'] = results['AWAY'].astype(object)
results['HOME_GOAL'] = results['HOME_GOAL'].astype(int)
results['AWAY_GOAL'] = results['AWAY_GOAL'].astype(int)
results['HOME_SHOT'] = results['HOME_SHOT'].astype(int)
results['AWAY_SHOT'] = results['AWAY_SHOT'].astype(int)
results['HOME_TSHOT'] = results['HOME_TSHOT'].astype(int)
results['AWAY_TSHOT'] = results['AWAY_TSHOT'].astype(int)
results['HOME_PASHOT'] = results['HOME_PASHOT'].astype(int)
results['AWAY_PASHOT'] = results['AWAY_PASHOT'].astype(int)
results['HOME_PATSHOT'] = results['HOME_PATSHOT'].astype(int)
results['AWAY_PATSHOT'] = results['AWAY_PATSHOT'].astype(int)
results['HOME_DRB'] = results['HOME_DRB'].astype(int)
results['AWAY_DRB'] = results['AWAY_DRB'].astype(int)
results['HOME_FSIN'] = results['HOME_FSIN'].astype(int)
results['AWAY_FSIN'] = results['AWAY_FSIN'].astype(int)
results['HOME_PASS'] = results['HOME_PASS'].astype(int)
results['AWAY_PASS'] = results['AWAY_PASS'].astype(int)
results['HOME_KPASS'] = results['HOME_KPASS'].astype(int)
results['AWAY_KPASS'] = results['AWAY_KPASS'].astype(int)
results['HOME_FPASS'] = results['HOME_FPASS'].astype(int)
results['AWAY_FPASS'] = results['AWAY_FPASS'].astype(int)
results['HOME_BPASS'] = results['HOME_BPASS'].astype(int)
results['AWAY_BPASS'] = results['AWAY_BPASS'].astype(int)
results['HOME_LPASS'] = results['HOME_LPASS'].astype(int)
results['AWAY_LPASS'] = results['AWAY_LPASS'].astype(int)
results['HOME_CROSS'] = results['HOME_CROSS'].astype(int)
results['AWAY_CROSS'] = results['AWAY_CROSS'].astype(int)
results['HOME_PASSSU'] = results['HOME_PASSSU'].astype(float)
results['AWAY_PASSSU'] = results['AWAY_PASSSU'].astype(float)
results['HOME_BATGRD'] = results['HOME_BATGRD'].astype(int)
results['AWAY_BATGRD'] = results['AWAY_BATGRD'].astype(int)
results['HOME_BATAIR'] = results['HOME_BATAIR'].astype(int)
results['AWAY_BATAIR'] = results['AWAY_BATAIR'].astype(int)
results['HOME_TACK'] = results['HOME_TACK'].astype(int)
results['AWAY_TACK'] = results['AWAY_TACK'].astype(int)
results['HOME_INTERSEP'] = results['HOME_INTERSEP'].astype(int)
results['AWAY_INTERSEP'] = results['AWAY_INTERSEP'].astype(int)
results['HOME_FOUL'] = results['HOME_FOUL'].astype(int)
results['AWAY_FOUL'] = results['AWAY_FOUL'].astype(int)
results['HOME_YLLCARD'] = results['HOME_YLLCARD'].astype(int)
results['AWAY_YLLCARD'] = results['AWAY_YLLCARD'].astype(int)
results['HOME_REDCARD'] = results['HOME_REDCARD'].astype(int)
results['AWAY_REDCARD'] = results['AWAY_REDCARD'].astype(int)
results.HOME=results.HOME.str.capitalize()
results.AWAY=results.AWAY.str.capitalize()
results_backup = results
## 홈 골 예측
HOME_GOALS = results.HOME_GOAL
for i in range (len(HOME_GOALS)):
if results.HOME_GOAL[i]>3:
HOME_GOALS[i]=3
else:
HOME_GOALS[i] = results.HOME_GOAL[i]
results.loc[:,'HOME_GOALS'] = pd.Series(HOME_GOALS,index=results.index)
y, X = dmatrices('HOME_GOALS ~ HOME_TSHOT + HOME_PATSHOT +\
HOME_FSIN + HOME_PASS + HOME_BPASS + \
HOME_CROSS + HOME_PASSSU + HOME_BATAIR',results, return_type="dataframe" )
y = np.ravel(y)
RegModel = LogisticRegression()
RegModel = RegModel.fit(X,y)
RegModel.score(X,y)
dfCoef = pd.DataFrame({'coef':X.columns, 'weight':RegModel.coef_[0]})
def homestats3(hometeam):
home_count = []
home_round = []
for i in range (len(results['HOME'])):
if results.HOME[i] == hometeam:
home_count.append(results.index[i])
for i in range(3):
home_round.append(max(home_count))
home_count.remove(max(home_count))
return(home_round)
def homestats5(hometeam):
home_count = []
home_round = []
for i in range (len(results['HOME'])):
if results.HOME[i] == hometeam:
home_count.append(results.index[i])
for i in range(5):
home_round.append(max(home_count))
home_count.remove(max(home_count))
return(home_round)
def homecount(hometeam):
home3 = results.loc[homestats3(hometeam)]
home3 = home3.reset_index()
HOME_TSHOT3 = (home3.HOME_TSHOT[0]+home3.HOME_TSHOT[1]+home3.HOME_TSHOT[2])/3
HOME_PATSHOT3 = (home3.HOME_PATSHOT[0]+home3.HOME_PATSHOT[1]+home3.HOME_PATSHOT[2])/3
HOME_FSIN3 = (home3.HOME_FSIN[0]+home3.HOME_FSIN[1]+home3.HOME_FSIN[2])/3
HOME_PASS3 = (home3.HOME_PASS[0]+home3.HOME_PASS[1]+home3.HOME_PASS[2])/3
HOME_BPASS3 = (home3.HOME_BPASS[0]+home3.HOME_BPASS[1]+home3.HOME_BPASS[2])/3
HOME_CROSS3 = (home3.HOME_CROSS[0]+home3.HOME_CROSS[1]+home3.HOME_CROSS[2])/3
HOME_PASSSU3 = (home3.HOME_PASSSU[0]+home3.HOME_PASSSU[1]+home3.HOME_PASSSU[2])/3
HOME_BATAIR3 = (home3.HOME_BATAIR[0]+home3.HOME_BATAIR[1]+home3.HOME_BATAIR[2])/3
home5 = results.loc[homestats5(hometeam)]
home5 = home5.reset_index()
HOME_TSHOT5 = (home5.HOME_TSHOT[0]+home5.HOME_TSHOT[1]+home5.HOME_TSHOT[2]+home5.HOME_TSHOT[3]+home5.HOME_TSHOT[4])/5
HOME_PATSHOT5 = (home5.HOME_PATSHOT[0]+home5.HOME_PATSHOT[1]+home5.HOME_PATSHOT[2]+home5.HOME_PATSHOT[3]+home5.HOME_PATSHOT[4])/5
HOME_FSIN5 = (home5.HOME_FSIN[0]+home5.HOME_FSIN[1]+home5.HOME_FSIN[2]+home5.HOME_FSIN[3]+home5.HOME_FSIN[4])/5
HOME_PASS5 = (home5.HOME_PASS[0]+home5.HOME_PASS[1]+home5.HOME_PASS[2]+home5.HOME_PASS[3]+home5.HOME_PASS[4])/5
HOME_BPASS5 = (home5.HOME_BPASS[0]+home5.HOME_BPASS[1]+home5.HOME_BPASS[2]+home5.HOME_BPASS[3]+home5.HOME_BPASS[4])/5
HOME_CROSS5 = (home5.HOME_CROSS[0]+home5.HOME_CROSS[1]+home5.HOME_CROSS[2]+home5.HOME_CROSS[3]+home5.HOME_CROSS[4])/5
HOME_PASSSU5 = (home5.HOME_PASSSU[0]+home5.HOME_PASSSU[1]+home5.HOME_PASSSU[2]+home5.HOME_PASSSU[3]+home5.HOME_PASSSU[4])/5
HOME_BATAIR5 = (home5.HOME_BATAIR[0]+home5.HOME_BATAIR[1]+home5.HOME_BATAIR[2]+home5.HOME_BATAIR[3]+home5.HOME_BATAIR[4])/5
HOME_TSHOT = (HOME_TSHOT3 + HOME_TSHOT5)/2
HOME_PATSHOT = (HOME_PATSHOT3 + HOME_PATSHOT5)/2
HOME_FSIN = (HOME_FSIN3 + HOME_FSIN5)/2
HOME_PASS = (HOME_PASS3 + HOME_PASS5)/2
HOME_BPASS = (HOME_BPASS3 + HOME_BPASS5)/2
HOME_CROSS = (HOME_CROSS3 + HOME_CROSS5)/2
HOME_PASSSU = (HOME_PASSSU3 + HOME_PASSSU5)/2
HOME_BATAIR = (HOME_BATAIR3 + HOME_BATAIR5)/2
HOME_count = RegModel.predict_proba([[0,HOME_TSHOT,HOME_PATSHOT,HOME_FSIN,HOME_PASS,HOME_BPASS,HOME_CROSS,HOME_PASSSU,HOME_BATAIR]])
return(HOME_count)
## 어웨이 골 예측
AWAY_GOALS = results.AWAY_GOAL
for i in range (len(AWAY_GOALS)):
if results.AWAY_GOAL[i]>3:
AWAY_GOALS[i]=3
else:
AWAY_GOALS[i] = results.AWAY_GOAL[i]
results.loc[:,'AWAY_GOALS'] = pd.Series(AWAY_GOALS,index=results.index)
y2, X2 = dmatrices('AWAY_GOALS ~ AWAY_SHOT + AWAY_TSHOT + \
AWAY_PATSHOT + AWAY_FSIN + AWAY_PASS + AWAY_BPASS',results, return_type="dataframe" )
y2 = np.ravel(y2)
RegModel2 = LogisticRegression()
RegModel2 = RegModel2.fit(X2,y2)
RegModel2.score(X2,y2)
dfCoef2 = pd.DataFrame({'coef':X2.columns, 'weight':RegModel2.coef_[0]})
def awaystats3(awayteam):
away_count = []
away_round = []
for i in range (len(results['AWAY'])):
if results.AWAY[i] == awayteam:
away_count.append(results.index[i])
for i in range(3):
away_round.append(max(away_count))
away_count.remove(max(away_count))
return(away_round)
def awaystats5(awayteam):
away_count = []
away_round = []
for i in range (len(results['AWAY'])):
if results.AWAY[i] == awayteam:
away_count.append(results.index[i])
for i in range(5):
away_round.append(max(away_count))
away_count.remove(max(away_count))
return(away_round)
def awaycount(awayteam):
away3 = results.loc[awaystats3(awayteam)]
away3 = away3.reset_index()
AWAY_SHOT3 = (away3.AWAY_SHOT[0]+away3.AWAY_SHOT[1]+away3.AWAY_SHOT[2])/3
AWAY_TSHOT3 = (away3.AWAY_TSHOT[0]+away3.AWAY_TSHOT[1]+away3.AWAY_TSHOT[2])/3
AWAY_PATSHOT3 = (away3.AWAY_PATSHOT[0]+away3.AWAY_PATSHOT[1]+away3.AWAY_PATSHOT[2])/3
AWAY_FSIN3 = (away3.AWAY_FSIN[0]+away3.AWAY_FSIN[1]+away3.AWAY_FSIN[2])/3
AWAY_PASS3 = (away3.AWAY_PASS[0]+away3.AWAY_PASS[1]+away3.AWAY_PASS[2])/3
AWAY_BPASS3 = (away3.AWAY_BPASS[0]+away3.AWAY_BPASS[1]+away3.AWAY_BPASS[2])/3
away5 = results.loc[awaystats5(awayteam)]
away5 = away5.reset_index()
AWAY_SHOT5 = (away5.AWAY_SHOT[0]+away5.AWAY_SHOT[1]+away5.AWAY_SHOT[2]+away5.AWAY_SHOT[3]+away5.AWAY_SHOT[4])/5
AWAY_TSHOT5 = (away5.AWAY_TSHOT[0]+away5.AWAY_TSHOT[1]+away5.AWAY_TSHOT[2]+away5.AWAY_TSHOT[3]+away5.AWAY_TSHOT[4])/5
AWAY_PATSHOT5 = (away5.AWAY_PATSHOT[0]+away5.AWAY_PATSHOT[1]+away5.AWAY_PATSHOT[2]+away5.AWAY_PATSHOT[3]+away5.AWAY_PATSHOT[4])/5
AWAY_FSIN5 = (away5.AWAY_FSIN[0]+away5.AWAY_FSIN[1]+away5.AWAY_FSIN[2]+away5.AWAY_FSIN[3]+away5.AWAY_FSIN[4])/5
AWAY_PASS5 = (away5.AWAY_PASS[0]+away5.AWAY_PASS[1]+away5.AWAY_PASS[2]+away5.AWAY_PASS[3]+away5.AWAY_PASS[4])/5
AWAY_BPASS5 = (away5.AWAY_BPASS[0]+away5.AWAY_BPASS[1]+away5.AWAY_BPASS[2]+away5.AWAY_BPASS[3]+away5.AWAY_BPASS[4])/5
AWAY_SHOT = (AWAY_SHOT3 + AWAY_SHOT5)/2
AWAY_TSHOT = (AWAY_TSHOT3 + AWAY_TSHOT5)/2
AWAY_PATSHOT = (AWAY_PATSHOT3 + AWAY_PATSHOT5)/2
AWAY_FSIN = (AWAY_FSIN3 + AWAY_FSIN5)/2
AWAY_PASS = (AWAY_PASS3 + AWAY_PASS5)/2
AWAY_BPASS = (AWAY_BPASS3 + AWAY_BPASS5)/2
AWAY_count = RegModel2.predict_proba([[0,AWAY_SHOT,AWAY_TSHOT,AWAY_PATSHOT,AWAY_FSIN,AWAY_PASS,AWAY_BPASS]])
return(AWAY_count)
try:
if home == home_name.capitalize() and away == away_name.capitalize():
future =()
else :
home = home_name.capitalize()
away = away_name.capitalize()
future = [[knumber,home,away]]
except:
future =()
pass
try:
if future != ():
home_score = homecount(home)
away_score = awaycount(away)
HOME = home
AWAY = away
H0 = (home_score[0][0])
H1 = (home_score[0][1])
H2 = (home_score[0][2])
H3 = (home_score[0][3])
A0 = (away_score[0][0])
A1 = (away_score[0][1])
A2 = (away_score[0][2])
A3 = (away_score[0][3])
Home_data = [H0,H1,H2,H3]
h_goal = Home_data.index(max(Home_data))
Away_data = [A0,A1,A2,A3]
a_goal = Away_data.index(max(Away_data))
H0 = str(round(H0,4))
H1 = str(round(H1,4))
H2 = str(round(H2,4))
H3 = str(round(H3,4))
A0 = str(round(A0,4))
A1 = str(round(A1,4))
A2 = str(round(A2,4))
A3 = str(round(A3,4))
if h_goal>a_goal:
HDA = 'H'
elif h_goal==a_goal:
HDA = 'D'
elif h_goal<a_goal:
HDA = 'A'
else:
HDA = 'error'
h_goal = str(h_goal)
a_goal = str(a_goal)
except:
future=()
pass
if future != ():
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = "select * from resultdb" # 경기 번호불러오기 위한 데이터
curs.execute(sql)
raw = curs.fetchall()
if raw != ():
num = str((int(raw[-1][0]))+1)
else:
num = '0'
li = [num,HOME,AWAY,HDA,h_goal,a_goal,H0,H1,H2,H3,A0,A1,A2,A3]
tu=""
for i in li:
tu = tu + "'"+ i + "',"
if future != ():
names = "K_NUMBER,HOME,AWAY,WIN,HOME_GOAL,AWAY_GOAL,H0,H1,H2,H3,A0,A1,A2,A3"
sqls= "INSERT INTO resultdb ("+names+") VALUES ("+tu[:-1]+")"
if future != ():
conn = pymysql.connect(host='125.176.85.154',port=3380, user='root', password='1234',
db='server', charset='utf8')
curs = conn.cursor()
sql = sqls
curs.execute(sql)
conn.commit()
# Connection 닫기
conn.close()
rowdata = ()
'Python 파이썬' 카테고리의 다른 글
| 파이썬 리스트에 있는 값들의 모든 조합구하기 (0) | 2021.07.11 |
|---|---|
| [파이썬] 상관분석 (Correlation Analysis) (0) | 2019.11.21 |
| [파이썬] 문자열 서식 (0) | 2019.10.09 |
| [파이썬] 간단한 팩토리얼 계산기 (0) | 2019.10.09 |
| [파이썬] 숫자야구게임 만들기 (0) | 2019.10.09 |
단순회귀분석(Simple Regression Analysis)
회귀분석이란 변수 사이의 인과관계를 증명하는 방법으로 단순회귀분석, 다중회귀분석, 로지스틱 회귀분석 등과 같이 종류가 다양합니다.
그 중에서 단순회귀분석은 하나의 독립변수(설명변수)와 하나의 종속변수(반응변수)에 대한 회귀분석을 말합니다.
이 블로그에서는 statsmodels 패키지를 사용하여 회귀분석한 것과, 텐서플로우를 사용하여 회귀분석한 것을 둘 다 해보겠습니다.
우선 statsmodels를 사용하여, 단순회귀분석을 구현해보겠습니다.
필요패키지를 가져옵니다.
import pandas as pd
import statsmodels.formula.api as sm
그 다음 데이터를 불러옵니다. 저는 가상의 데이터를 불러오겠습니다.
df = pd.read_csv('simpledata.csv')
이제 회귀 분석을 합니다.
model = sm.ols(formula = 'v2 ~ v1', data = df).fit()
model.summary()
과정에 따라 다르게 적용되지만 적용 기준이 없을 경우, 일반적으로 p값(P>|t| , 유의확률)이 0.05가 넘으면 무의미한 변수라고 하며 단순회귀분석을 할 수 없습니다. Adj.R-squared 는 조정 결정 계수로 0과 1사이에 있으며, 종속 변수와 독립변수 사이에 상관관계(인과관계가 아닙니다)가 높을수록 1에 가까워집니다.
예시로 만든 그림을 보면 회귀식은 y(hat)=0.0991*v1+0.5051 으로 나오며, 만약 v1의 값이 1이라면 v2의 값은 0.6042라고 예측합니다.
이제 텐서플로우에서 단순회귀분석을 구현해보겠습니다.
필요패키지를 불러옵니다.
import pandas as pd
import numpy as np
import tensorflow as tf
import os
그 다음 데이터를 불러옵니다. 위에서 사용한 데이터를 다시 불러오겠습니다.
df = pd.read_csv('simpledata.csv')
그 후, 두 변수를 다루기 편하도록, 넘파이 행렬로 변환합니다.
data_y = np.array(df.v2)
data_x = np.array(df.v1)
이제 본격적으로 텐서플로우를 사용하겠습니다.
우선, simplesimple_regresstion 이라는 이름을 가진 그래프를 그립니다.
그 후, 외부데이터를 받아서 저장하는 변수인 placeholder를 그래프에 2개 추가합니다.
다음으로 상수를 정의하는 constant를 그래프에 추가합니다.
학습 중에 계속 변하는 변수인 get_variable을 두 개 추가시킵니다.
여기까지가 선형회귀에 필요한 변수입니다.
그 다음으로는 오차를 지정해주며, 이 오차를 줄이기위해 저는 경사하강법(GradientDescent Algorithm)을 사용하였습니다.
with tf.Graph().as_default() as simple_regresstion:
X = tf.placeholder(tf.float32, [None], name='X')
Y = tf.placeholder(tf.float32, [None], name='Y')
lr = tf.constant(1e-3,tf.float32)
W = tf.get_variable("W",dtype=tf.float32,initializer=tf.constant(1.,tf.float32))
b = tf.get_variable("b",dtype=tf.float32,initializer=tf.constant(1.,tf.float32))
h = W*X + b
cost = tf.reduce_mean(tf.square(tf.subtract(h,Y)))
train = tf.train.GradientDescentOptimizer(lr).minimize(cost)
여기까지가 그래프를 그리는 과정입니다.
이제 Session을 사용하여 방금 만든 그래프를 불러와 학습을 시킵니다.
with tf.Session(graph = simple_regresstion) as sess:
sess.run(tf.global_variables_initializer())
for i in range(2000):
_,l = sess.run([train,cost],feed_dict={X:data_x,Y:data_y})
print("cost",l)
weight, bias = sess.run([W,b])
print(weight, bias)range에 있는 숫자를 변화시켜 학습횟수를 변경시킬 수 있습니다.
print("cost",1) 를 통해 오차가 줄어드는 것을 확인할 수 있으며, print(weight, bias)를 통해 회귀계수를 확인할 수 있습니다.
print(weight*1+bias)
예시 데이터로 v1에 1을 넣었을 때, v2는 0.7041902616620064가 나왔습니다.
이제 텐서플로우로 만든 회귀식을 그래프로 그려보겠습니다.
필요패키지입니다.
import matplotlib.pyplot as plt
그래프를 그리는 코드입니다.
plt.scatter(data_x,data_y)
plt.plot(data_x,data_x*weight+bias,'r')
plt.show()
찍힌 점들은 실제 데이터 점이며, 그어진 직선이 단순선형회귀를 통해 구해진 모델입니다.
'Python 파이썬 > 머신러닝' 카테고리의 다른 글
| 군집 분석 (클러스터 분석) (0) | 2019.11.12 |
|---|---|
| K-최근접 이웃 알고리즘 (KNN) 간단한 파이썬 코드 (0) | 2019.11.11 |
| K-최근접 이웃 알고리즘 (KNN) (0) | 2019.11.11 |
| 범주형 데이터 선형회귀 분석하기 (2) | 2019.11.06 |
| 넘파이 NumPy (0) | 2019.10.11 |
상관분석(Correlation Analysis)
상관분석은 두 변수간에 어떤 선형적 또는 비선형적 관계를 갖고 있는지를 분석하는 방법입니다.
두 변수간의 관계의 강도를 상관관계라고 하며, 그 정도를 파악하는 것을 상관 계수라고 합니다.
상관계수는 두 변수간의 연관된 정도를 나타낼 뿐 인과관계를 설명하는 것은 아닙니다.
이제 파이썬에서 상관분석을 하는 법을 알아보겠습니다.
우선 판다스를 불러옵니다.
import pandas as pd
그 후 데이터 프레임을 불러오거나 제작합니다.
저는 일단, 가상의 데이터를 만들겠습니다.
df = pd.DataFrame({"v1":[100,200,300,400], "v2":[400,200,100,250], "v3":[40,60,60,100]})
이제 상관분석을 하겠습니다. 저는 피어슨 상관 계수를 사용하겠습니다.
corr = df.corr(method = 'pearson')
corr
피어슨의 상관계수는 일반적으로,
값이 -1.0 ~ -0.7 이면, 강한 음적 상관관계
값이 -0.7 ~ -0.3 이면, 뚜렷한 음적 상관관계
값이 -0.3 ~ -0.1 이면, 약한 음적 상관관계
값이 -0.1 ~ +0.1 이면, 없다고 할 수 있는 상관관계
값이 +0.1 ~ +0.3 이면, 약한 양적 상관관계
값이 +0.3 ~ +0.7 이면, 뚜렷한 양적 상관관계
값이 +0.7 ~ +1.0 이면, 강한 양적 상관관계
로 해석됩니다.
이제 상관분석을 시각화 하겠습니다.
matplotlib은 파이썬에서 기본적인 차트를 쉽게 그릴 수 있도록 도와주는 데이터 시각화 라이브러리입니다.
seaborn은 matplotlib을 기반으로 만들어져 통계 데이터 시각화에 최적화된 라이브러리입니다.
이 두 개를 불러옵니다.
import matplotlib.pyplot as plt
import seaborn as sns
그 후, 상관분석에 대한 히트맵을 그립니다.
df_heatmap = sns.heatmap(corr, cbar = True, annot = True, annot_kws={'size' : 20},
fmt = '.2f', square = True, cmap = 'Blues')
cbar는 오른쪽에 있는 막대(범주)를 표시하는 것입니다.
annot는 상관계수를 표시합니다.
annot_kws는 상관계수의 글자 크기를 지정합니다.
fmt 는 상관계수의 소수점 자리수를 지정합니다.
square는 정사각형으로 지정하는 것이며, False로 설정 시 직사각형이 됩니다.
cmap은 색상을 지정합니다.
'Python 파이썬' 카테고리의 다른 글
| 파이썬 리스트에 있는 값들의 모든 조합구하기 (0) | 2021.07.11 |
|---|---|
| K리그 축구 승부 예측 프로그램 (Python 부분) (1) | 2021.06.18 |
| [파이썬] 문자열 서식 (0) | 2019.10.09 |
| [파이썬] 간단한 팩토리얼 계산기 (0) | 2019.10.09 |
| [파이썬] 숫자야구게임 만들기 (0) | 2019.10.09 |
군집분석은 주어진 데이터셋 내에서 각 객체의 유사성을 측정하여 집단을 분류하고 군집으로 나누는 비지도 기계 학습 기법입니다. 데이터의 분할 및 요약에 널리 사용되고 있으며, 데이터에서 유용한 지식을 추출하는 데 활용됩니다.
군집분석을 통해 수백만의 데이터를 직접 확인하지 않고 각각의 대푯값만을 확인해 전체 데이터의 특성을 파악할 수 있습니다.
군집을 분류하는 데 있어 가장 기본적인 가정은 군집 내에 속한 객체들의 특성은 서로 동질적이고, 다른 군집에 속한 객체들 간의 특성은 서로 이질적이 되도록 분류해야 합니다.
군집화를 수행할 시 주요적으로 고려할 사항으로는 어떤 알고리즘을 사용할지, 어떤 거리 척도를 사용할지, 최적 군집 수는 어떻게 결정할지 등이 있습니다.
대표적인 군집분석기법으로는 k-means이 있으며, partitioning, categorical, k-medoid, clara, clarans 등이 있습니다.
객체의 종류에 따라 다양한 유사도 기준이 적용됩니다. 대표적인 유사도 척도로 유클리디안 거리가 있으며, 맨하탄 거리, 마할라노비스 거리, 상관계수 거리 등이 있습니다.
'Python 파이썬 > 머신러닝' 카테고리의 다른 글
| [파이썬, 텐서플로우] 단순회귀분석 (Simple Regression Analysis) (2) | 2019.11.21 |
|---|---|
| K-최근접 이웃 알고리즘 (KNN) 간단한 파이썬 코드 (0) | 2019.11.11 |
| K-최근접 이웃 알고리즘 (KNN) (0) | 2019.11.11 |
| 범주형 데이터 선형회귀 분석하기 (2) | 2019.11.06 |
| 넘파이 NumPy (0) | 2019.10.11 |
이론 부분은 전편에서 확인해주세요(https://sno-machinelearning.tistory.com/61)
K-최근접 이웃 알고리즘 (KNN)
K-최근접 이웃 알고리즘은 특정 공간 내에서 입력과 가장 근접한 K개의 요소를 찾아서 더 많이 일치하는 것으로 분류하는 알고리즘으로 가장 간단한 기계학습 알고리즘입니다. 그림으로 살펴보도록 하겠습니다...
sno-machinelearning.tistory.com
KNN알고리즘을 파이썬으로 간단하게 표현했습니다.
우선 필요 패키지부터 불러옵니다.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt그 후 데이터를 불러옵니다. (데이터는 네이버의 2019년 자동차 데이터 중 일부를 가져왔습니다.)
data = pd.read_csv('cars.csv', encoding="euc-kr")
data.city_mpg = data.city_mpg*10 # 변수끼리 간단하게나마 비율을 맞추었습니다.
df_z = np.array(data.fuel)
df_xy = data[["hp", "city_mpg"]]
data_xy = df_xy.as_matrix()
그다음에는 새롭게 분류할 데이터를 생성합니다.
hp = int(input('마력 입력 : '))
mpg = float(input('도심연비 입력 : '))*10
target = [hp, mpg]
dataset을 만들어 데이터를 분석하기 쉽게 만들어, 분류대상 및 범주를 생성합니다.
def data_set():
size = len(df_xy)
class_target = np.tile(target, (size, 1))
class_z = np.array(df_z)
return df_xy, class_target, class_z
dataset, class_target, class_z = data_set()유클리디안 거리 공식(Euclidean Distance)을 이용하여, 분류할 대상과 분류범주와의 거리를 구합니다.
그후, 가까운 값에따라 오름차순으로 정렬한 후 그 값에 따라 어떤 카테고리에 가까운지 분류합니다.
def classify(dataset, class_target, class_category, k):
diffMat = class_target - dataset
sqDiffMat = diffMat**2
row_sum = sqDiffMat.sum(axis=1)
distance = np.sqrt(row_sum)
sortDist = distance.argsort()
class_result = {}
for i in range(k):
c = class_category[sortDist[i]]
class_result[c] = class_result.get(c, 0) + 1
return class_result
이제 k값을 입력하는 코드와 함수를 호출하는 코드를 작성합니다.
k = int(input('k값을 입력해주세요 :'))
class_result = classify(data_xy, class_target, class_z, k) # classify()함수호출
print(class_result)
k값을 입력해주세요 :5
{'가솔린': 3, '디젤': 2}
위의 결과를 확인하였을 때, 내가 분류할 대상은 '가솔린' 연료 사용 카테고리에 가장 가까운 것을 알 수 있습니다.
def resultprint(class_result):
hev = Gas = die = 0
for c in class_result.keys():
if c == '하이브리드':
hev = class_result[c]
elif c =='가솔린':
Gas = class_result[c]
else :
die = class_result[c]
if hev > Gas and hev > die:
result = "분류대상은 하이브리드 입니다."
elif Gas > die and Gas > hev:
result = "분류대상은 가솔린 입니다"
elif die > hev and die > Gas:
result = "분류대상은 디젤 입니다."
else:
result = "k값을 변경해주세요."
return result
print(resultprint(class_result))
출력결과로는
분류대상은 가솔린 입니다.
라고 나올것입니다.
밑의 그림은 보기 쉽도록 시각화한 그래프입니다.
파란색 동그라미가 가솔린, 녹색 십자가가 하이브리드, 회색 엑스가 디젤입니다. 그리고 적색 별이 타켓입니다.
그래프는 밑에 있는 코드로 작성할 수 있습니다.
for c in range(len(df_xy)):
data_xy[c][1] = data_xy[c][1]/10
if df_z[c] == '가솔린':
plt.scatter(data_xy[c][0],data_xy[c][1],marker='o',color='b')
elif df_z[c] == '하이브리드':
plt.scatter(data_xy[c][0],data_xy[c][1],marker='+',color='g')
else:
plt.scatter(data_xy[c][0],data_xy[c][1],marker='x',color='gray')
plt.scatter(hp,mpg/10,marker='*',color='r')
plt.show()
출처 :
자동차 데이터 (https://auto.naver.com/car/mainList.nhn)
'Python 파이썬 > 머신러닝' 카테고리의 다른 글
| [파이썬, 텐서플로우] 단순회귀분석 (Simple Regression Analysis) (2) | 2019.11.21 |
|---|---|
| 군집 분석 (클러스터 분석) (0) | 2019.11.12 |
| K-최근접 이웃 알고리즘 (KNN) (0) | 2019.11.11 |
| 범주형 데이터 선형회귀 분석하기 (2) | 2019.11.06 |
| 넘파이 NumPy (0) | 2019.10.11 |
K-최근접 이웃 알고리즘은 특정 공간 내에서 입력과 가장 근접한 K개의 요소를 찾아서 더 많이 일치하는 것으로 분류하는 알고리즘으로 가장 간단한 기계학습 알고리즘입니다.
그림으로 살펴보도록 하겠습니다.
최근접 이웃 알고리즘은 그림 속의 물음표의 주변에 세모가 있기 때문에 세모라고 판단하는 알고리즘입니다.
다음 그림도 살펴보겠습니다.
위의 그림은 주변에서 몇 개를 골라서 볼 것인가에 따라 물음표의 분류가 바뀝니다.
이렇게 주변에 있는 몇 개의 요소들을 같이 봐서 가장 많이 골라내는 것을 K-최근접 이웃 알고리즘(KNN)이라고 할 수 있습니다. KNN 알고리즘에서 K는 주변의 개수를 의미한다고 보시면 됩니다.
K가 1일 때는 동그라미라고 판단하겠지만, K를 3으로 변경한다면 세모라고 판단할 것입니다.
하지만 문제가 있습니다. 과연 K는 몇인가 가장 좋을까요?
위의 그림에서 확인할 수 있듯이, 물음표를 네모인지 세모인지 결론을 내릴 수 없게 됩니다.
위의 그림 처럼 k값이 커지면 항목 간의 경계가 불분명해지며, 결론을 내기 더 힘들어 질 수 있습니다.
이진(2개의 항목) 분류 문제에서는 홀수인 K를 선택하는 것이 바람직 하지만 항목이 여러개일 수도 있습니다.
따라서, KNN알고리즘을 사용할 때는 분류될 그룹의 종류등을 고려하여 적절한 K값을 설정하는 것이 중요합니다.
'Python 파이썬 > 머신러닝' 카테고리의 다른 글
| 군집 분석 (클러스터 분석) (0) | 2019.11.12 |
|---|---|
| K-최근접 이웃 알고리즘 (KNN) 간단한 파이썬 코드 (0) | 2019.11.11 |
| 범주형 데이터 선형회귀 분석하기 (2) | 2019.11.06 |
| 넘파이 NumPy (0) | 2019.10.11 |
| 머신러닝의 개념 (0) | 2019.10.09 |
아는 사람이 졸업작품으로 '날씨에 따른 중국집 배달 수를 조사'하고 싶다고 하여서 참고하라고 만들어보았습니다.
우선 필요할 듯한 패키지입니다.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import matplotlib.ticker as plticker
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import os
import tensorflow as tf
import statsmodels.formula.api as sm
from patsy import dmatrices
지인의 데이터를 확인하지 못하여 임의로 만들었습니다.
x1 x2 x3
1 0 0 - 맑음
0 1 0 - 흐림
0 0 1 - 비
0 0 0 - 눈
순위가 정해지지 않은 범주형 데이터를 분석할 때에는 변수를 위와 같이 만들어야합니다.
일단 데이터를 불러옵니다.
data = pd.read_csv('data.csv')
model = sm.ols(formula = 'y ~ x1 + x2 + x3',data=data).fit()
model.summary()
선형회귀표입니다.
P>|t| 가 0.05 보다 높으면 쓸모 없는 변수이지만, x1,x2,x3는 날씨라고 하는 한 변수의 더미변수이기 때문에 전부 버려야하는 상황이 아니면 버리지 않습니다.
Adj.R-squared 는 수정된 상관관계입니다. 실제로 종속변수에 영향을 주는 독립변수들에 의해 설명되는 분산의 비율을 알려줍니다. 이번 블로그의 주제인 '날씨에 따른 중국집 배달 수를 조사'는 사회과학에 속하기에 시계열, 패널 데이터가 아닌 이상 결정계수가 낮을 가능성이 매우 크지만, 적절한 추정방법을 사용했다면 작더라도 상관은 없습니다.
다루기 편하게 x와 y를 NumPy 배열로 변경합니다.
multi_y = np.array(data.y)
df_x = data[["x1", "x2", "x3"]]
multi_x = df_x.as_matrix()
그 다음부터는 본격적으로 tensorflow를 사용하겠습니다.
with tf.Graph().as_default() as multi_regresstion:
num_x = 3 # x변수는 몇개?
X = tf.placeholder(tf.float32, [None, num_x], name='X')
Y = tf.placeholder(tf.float32, [None], name='Y')
lr = tf.constant(1e-3,tf.float32)
W = tf.get_variable("W", [1,num_x], tf.float32)
b = tf.get_variable("b",dtype=tf.float32,initializer=tf.constant(1.,tf.float32))
h = tf.matmul(W,X,transpose_b=True) + b
cost = tf.reduce_mean(tf.square(tf.subtract(h,Y)))
train = tf.train.GradientDescentOptimizer(lr).minimize(cost)우선 multi_regresstion이라는 이름을 가진 그래프를 만듭니다.
그후 placeholder 2개를 그래프에 추가합니다. placeholder는 외부데이터를 받아서 저장하는 변수로,
tf.placeholder(자료형, 텐서모양,이름)으로 구성됩니다.
tf.constant는 상수를 정의해주며, tf.constant(값, 자료형)으로 구성됩니다.
tf.get_variable은 학습 중에 계속 변하는 변수이며, tf.get_variable(이름,자료형,초기값)으로 구성됩니다.
여기까지가 선형회귀에 필요한 변수입니다.
cost는 계산할 오차이며, 이 오차를 줄이기 위해 GradientDescent알고리즘을 이용하였습니다.
이제 그래프 그리기는 모두 끝났으며, Session을 사용하여 방금 만든 그래프를 불러옵니다.
with tf.Session(graph=multi_regresstion) as sess:
sess.run(tf.global_variables_initializer())
for i in range(3000):
_,l = sess.run([train,cost],feed_dict={X:multi_x,Y:multi_y})
print("loss",l)
W_multi, b_multi = sess.run([W,b])
학습을 진행할 수록 loss(cost)가 줄어드는 것을 볼 수 있습니다. (만약 NA값이 뜨거나 점점 커지면 식의 설명력이 너무 낮아서 변수를 바꾸거나 다른 방법을 써야 합니다. 이건 나중에 쓸 일이 있으면 올리겠습니다.)
for j in range(len(multi_x)):
sum = 0
for i in range(3):
sum += W_multi[0][i] * multi_x[j,i]
print(multi_y[j],sum+b_multi)
print(W_multi,b_multi)
이제 학습을 마쳤으니 결과를 확인할 차례입니다.
실행시에 위와 비슷한 결과가 나옵니다.
결과적으로
h = -2.593823*x1 + 1.0692451*x2 + 3.6352885*x3 + 5.5272436
라는 식을 얻을 수 있습니다.
def weather(weather):
if weather == '맑음':
a,b,c = 1,0,0
elif weather == '흐림':
a,b,c = 0,1,0
elif weather == '비':
a,b,c = 0,0,1
elif weather == '눈':
a,b,c = 0,0,0
else:
a,b,c = 'error'
d = W_multi[0][0]*a+W_multi[0][1]*b+W_multi[0][2]*c+b_multi
return(a,b,c,d)
이제 새로운 값을 얻었을 경우 값 예측을 만들면 됩니다.
weather('눈')
'Python 파이썬 > 머신러닝' 카테고리의 다른 글
| 군집 분석 (클러스터 분석) (0) | 2019.11.12 |
|---|---|
| K-최근접 이웃 알고리즘 (KNN) 간단한 파이썬 코드 (0) | 2019.11.11 |
| K-최근접 이웃 알고리즘 (KNN) (0) | 2019.11.11 |
| 넘파이 NumPy (0) | 2019.10.11 |
| 머신러닝의 개념 (0) | 2019.10.09 |