'전체 글'에 해당되는 글 67건
- 2021.07.11 :: 파이썬 리스트에 있는 값들의 모든 조합구하기
- 2021.06.18 :: K리그 축구 승부 예측 프로그램 (Python 부분) 1
- 2021.06.02 :: [R] ggplot2 발표 자료 코드
- 2020.05.20 :: BNK·DGB·JB금융, 빅데이터 플랫폼 구축…‘디지털 전환’ 가속
- 2019.11.21 :: [파이썬, 텐서플로우] 단순회귀분석 (Simple Regression Analysis) 2
- 2019.11.21 :: [파이썬] 상관분석 (Correlation Analysis)
- 2019.11.20 :: 변수 선택법
- 2019.11.14 :: ‘삼성 AI 포럼 2019’ 기술 한계 극복을 위해 글로벌 전문가 한 자리에
하나의 리스트에 있는 값들의 모든 조합구하기
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 |
# 대부분 인스톨이 되어 있겠지만 혹시 안되시는 분들을 위해 패키지 인스톨부터시작 하겠습니다
# 우선은 intall.packages를 활용해 ggplot2를 인스톨 받으신후 라이브러리를 통해 ggplot2를 적용 시키시면 됩니다.
ggplot2
install.packages("ggplot2")
library(ggplot2)
install.packages("gridExtra")
library(gridExtra)
#grid.arrange(p1, p2, ncol=2)
##########+############################################################################
#저희가 활용할 객체는 ggplot의 객체인 diamonds입니다.
#View를 활용해서 정보를 보도록 하겠습니다.
View(diamonds)
#diamonds에는 질적자료와 양적자료가 있는데, 질적자료 3가지를 찾아주시기 바랍니다.
#혹시 질적자료와 양적 자료가 헷갈리시면 str을 이용해 편하게 구분 하실 수 있습니다.
str(diamonds)
# diamiond의 자료구성입니다.
# 질적자료는 숫자로 표시될 수 없는 자료를 가르킴으로 fctor형인 cut, clarity, color가 있습니다.
# 그외의 자료들은 양적자료로 자료 자체가 숫자로 표현되어 있다. 여기서는 carat,depth,table,price 등이 있습니다.
# 앞에서 배웠던 것을 토대로 cut에 대해 그래프로 표현해 보시기 바랍니다.
# 힌트는 cut은 질적자료이며, x축만 제공하기에 막대형식의 그래프를 사용하시면 됩니다.
# 안되거나 기억이 안나시는 부분은 손들어주시면 보조강사분들이 가겠습니다.
#qplot과 ggplot으로 작성하신 분들이 있을텐데요
#qpolt과 ggplot의 차이는 무엇일까요? 츄파춥스준다.
#qplot은(quick plot)으로 데이터와 표현방식을 함께 기입하여 코드의 길이가 매우 짧으며 간단한 반면에
#ggplot은 데이터 입력후 "+"를 사용해 그래프 형식을 정해주어야합니다. 불편해 보이지만 +를 사용함으로 추가가 용이합니다.
#ggplot이 더 복잡한 작업을 할때 시각화부분에 더 강력하다고 할 수 있습니다.
#말 그대로 qplot은 빠르게 plot 할 때 (그래프를 그릴 때) 사용하는 것이고
#ggplot(grammer of graphic)은 문법대로 더 상세하게 구현할 때 사용한다고 한다
qplot(cut,data=diamonds)
qplot(cut,data=diamonds,geom="bar",xlab="cut",ylab="count") #geom의 default값이 "bar", ylab으로 이름설정
ggplot(data=diamonds, aes(x=cut))+geom_bar() #이와 같이 작성은 가능하지만
g <- ggplot(data=diamonds, aes(x=cut)) #어떤 데이터를 사용할 것인지만 지정된 상태
g + geom_bar() #변수에 데이터를 넣은 후 출력형식을 +로 연결해주시면 됩니다.
#이와같이 지속적으로 추가시킬수 있습니다.
# x축만 제공됨으로 y축이 필요한 함수는 추가할 수 없습니다.
# cut의 막대그래프 - 질적 변수인 cut을 기준으로 도수의 크기를 비교한 막대그래프
###########################################################################################
# 방금전에 cut은 질적자료였죠 그럼 carat은 무슨 자료일까요?
# 잘적자료는 바를 사용한다면 양적자료는 무엇을 사용할까요?
# 막대그래프와 히스토그램의 차이가 무엇인가요?
# carat을 그래프로 표현해 보시기 바랍니다.
g <- ggplot(data=diamonds, aes(x=carat))
g + geom_histogram(binwidth = 1 )
g + geom_histogram(binwidth = 0.1 )
g + geom_histogram(binwidth = 0.05 )
# 앞의 히스토그램의 계급의 수를 변경하는 등 작성자의 주관적인 판단에 좌우되어 해석이 좌우된다.
##############################################################################################
#다음은 line을 실습해 보겠습니다.
#line은 질적변수를 사용하지 않고 X축과 Y축 변수가 필요합니다.
#x축은 케럿 y축은 프라이스로 line을 만들어보세요
g <- ggplot(data=diamonds, aes(x=carat,y=price))
g+geom_line()
#x,y값만으로 했을때 그래프가 변동이 심하죠 이거는 다른 변동요인 있을 수 있다는걸 뜻합니다.
#컬러변수를 넣어서 확인해볼까요"?
g+geom_line(aes(colour=color))
#캐럿에 따라 가격 상승, 색에따라서 가격 상승
# line여기서 마치고 이어서 point부터는 이용희학생이 진행하겠습니다.
#############################################
# 이어서 발표하겠습니다.(지옴 지오메틱)
# 포인트 그래프는 x축과 y축을 설정한 뒤 geom_point()를 추가하면 그려집니다.
# 케럿과 프라이스 변수로 포인트 그래프를 만들어보세요.
ggplot(data=diamonds, aes(x=carat,y=price)) +
geom_point()
# 수많은 점이 찍힌것을 볼 수 있으시죠?
# 이제 이 그래프에 깨끗한 정도의 변수를 넣어 색을 변경해보겠습니다.
# 변수에 따라 point를 다르게 표현하고 싶다면 aes에서 설정해주면 됩니다.
# aes에 컬러는 클라리티를 넣어 확인해봅시다.
ggplot(data=diamonds, aes(x=carat,y=price, colour=clarity)) +
geom_point()
# 클라리티 변수에 따라 포인트들의 색이 변경되었음을 보실 수 있으실겁니다.
# 그래프를 보시면 노란색 점, 즉 결점이 적은 다이아가 위쪽으로 많이 분포해있고,
# 검은색 점이 아래쪽에 많이 분포되어있음을 알 수 있습니다.
# 간단하게 해석해보면 다이아몬드에 결점이 적을수록
# 가격이 높으며, 무게가 큰 것을 찾기 힘들어진다는 것을 알 수 있습니다.
#
# 이제 추세선을 그려보겠습니다.
# 앞에 있었던 포인트나 라인같이 무수한 데이터들로 이루어진 산포도로는
# 그 경향을 읽어내기가 어렵습니다.
# 이런 경우, 추세선을 통해 그 경향을 읽을 수 있습니다.
# 추세선은 geom=smooth를 통해 표현할 수 있습니다.
# 앞에 그렸던 포인트 그래프에 스무스를 추가하여 보세요.
ggplot(data=diamonds, aes(x=carat,y=price, colour=clarity)) +
geom_point()+
geom_smooth()
# (만약 포인트에 aes를 넣어 만든사람은 한개의 회귀선만 나타난다. ase(colour=clarity)라는
# 옵션은 디폴트로 주어진 것이 아니라 추가적인 레이어에서 새롭게 설정된 값이라서)
# 그래프를 보시면 clarity에 따른 각각의 회귀선이 나타남을 알 수 있습니다.
# 이는 맨 처음 레이어에서 colour=clarity옵션까지 디폴트로 적용되었기 때문입니다.
# 이제 박스플롯을 그려보겠습니다.
# boxplot은 중앙값, 최대값, 최솟값, 사분위를 사용하여 자료의 측정값들이 어떤 모양
# 으로 분포되어 있는지 알려줍니다.
# 클라리티와 케럿에 대한 상자그림을 그려보세요.
ggplot(data=diamonds, aes(x=clarity,y=carat)) +
geom_boxplot()
# boxplot을 통해서 이상치나 자료의 대칭성, 산포도, 중앙값등을 한 눈에 볼 수 있습니다.
# boxplot의 색과 크기는 fill,color,width 지정을 통해 바꾸어 줄 수 있습니다.
ggplot(data=diamonds, aes(x=clarity,y=carat)) +
geom_boxplot(fill='slategrey',color='darkslategrey',width=0.3)
# (이상치를 없애려면 oulier.shape를 NA로 지정해주시면 됩니다.)
# 중앙값 이외에도 평균을 알고 싶다면 stat_summary를 통해 평균을 추가해줄 수 있습니다.
ggplot(data=diamonds, aes(x=clarity,y=carat)) +
geom_boxplot()+
# fun.y 인자를 설정해주면 x값에 대응하는 y값을 구할 수 있습니다.
# stat_summary 함수에서 fun.y 인자에 mean을 입력해주면 그래프에 평균값이 나타나게 됩니다.
stat_summary(fun.y="mean", geom="point", shape=22, size=3, fill="blue")
# 박스플롯에 분포의 형태를 보다 구체적으로 표현하는 방법으로는 violin plot이 있습니다.
# 클라리티와 프라이스의 바이올린 플롯을 그려보세요
ggplot(data=diamonds, aes(x=clarity,y=price)) +
geom_violin()
# 바이올린 그래프를 보면 분포가 옆으로 나열되기 때문에 아까 봤던 포인트처럼 데이터가
# 무수히 많을 때 분포를 비교하기 힘들었던 자료도 쉽게 비교할 수 있습니다.
# 이렇게 기초 통계와 ggplot2의 그래프들 중 7가지 그래프를 알아봤습니다.
'R 프로그래밍' 카테고리의 다른 글
| 2019년 자동차 데이터 분석 (0) | 2019.11.06 |
|---|---|
| GGPLOT2을 이용한 데이터 분석 (DIAMOND) (0) | 2019.11.06 |
| 설문조사를 통한 유튜브 특성 조사 (0) | 2019.11.06 |
| [R프로그래밍] 통계관련함수 (0) | 2019.10.06 |
| [R프로그래밍] 연산자 (0) | 2019.10.06 |
출처 입니다.
http://www.mediapen.com/news/view/526524
BNK·DGB·JB금융, 빅데이터 플랫폼 구축…‘디지털 전환’ 가속
[미디어펜=이동은 기자] 지방금융지주들이 빅데이터 플랫폼을 구축하면서 디지털 전환에 박차를 가하고 있다. 인공지능(AI) 기반의 시스템을 통해 방대한 데이터를 분석하고 이를 기반으로 맞춤
www.mediapen.com
내용 요약
각 금융들이 빅데이터 시장의 주도권을 잡기 위해 기존의 통계시스템 대신 머신러닝 기반의 AI 시스템을 도입한다고 합니다.
로보 어드바이져 플랫폼
웹 또는 모바일 플랫폼을 통해 인간의 개입을 최소화하며, 자동화된 금융자문 서비스를 제공하는 것
머신러닝, 빅데이터 등의 IT 기술과 금융이론이 결합되어 컴퓨터가 자산을 관리하도록 하는 기술을 사용한 플랫폼입니다.
(주의 : 운용하는 회사마다 명칭이나 정의가 다릅니다.)
'기타 > IT 관련 뉴스 기사수집' 카테고리의 다른 글
| ‘삼성 AI 포럼 2019’ 기술 한계 극복을 위해 글로벌 전문가 한 자리에 (0) | 2019.11.14 |
|---|---|
| AI튜터 출시, AI기술로 영어 공부 (0) | 2019.11.13 |
| 연주자 감성까지 반영하는 '음악AI'연구 (0) | 2019.11.11 |
| 대학생에게 홈쇼핑 데이터를 주면 매출을 예측할 수 있을까? (0) | 2019.11.08 |
| 더존비즈온, '위하고' 기반으로 이커머스 사업 진출 (0) | 2019.11.07 |
단순회귀분석(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 |
회귀 모델을 만들 때 주어진 여러 변수 중, 어떤 변수를 설명 변수로 해야할 지는 모델링을 수행하는 사람의 배경 지식에 따라 결정됩니다.
하지만 이러한 배경 지식이 없거나, 배경 지식은 있어도 여전히 어떠한 변수들을 선택해야할지 정확히 결정하기 힘들다면, 변수의 통계적인 특성을 고려해 기계적으로 설명 변수를 선택하는 방법이 있습니다.
이러한 방법들을 통틀어서 변수 선택법이라고 합니다.
변수선택법에는 다음과 같은 알고리즘이 있습니다.
부분집합법(all subset) : 모든 가능한 모델을 고려하여 가장 좋은 모델을 선정하는 방법입니다. 번수의 개수에 따라 검증해야하는 회귀분석이 많아지기에 엑셀, R, 파이썬에서 모두 추천하지는 않지만, 변수의 개수가 적거나 최대한 설명력을 높이려면 생각해 볼 만 합니다.
후진제거법(Backward Eilmination) : 모든 변수를 넣은 모델에서 p 값을 기준으로 전체에서 1 개씩 제거하여 모든 변수가 유의미하며, 더 이상 제거할 변수가 없을 때 까지 제거하는 방법입니다. 파이썬과 액셀에서는 변수선택법 함수를 지원하지 않기에, 개인적으로는 이 방법을 추천드리고 싶습니다.
전진선택법(Forward Selection) : 절편만 있는 모델에서 기준 통계치를 가장 많이 개선시키는 변수를 차례로 추가하는 방법입니다.
단계적 선택법(Stepwise Selection) : 예측변수를 연속적으로 추가/삭제하면서 AIC (AIC 지표 : 회귀모델에 항을 추가할수록 불이익을 주는 지표)가 낮아지는 모델을 찾는 방법입니다. 후진제거법과 전진선택법이 가지고 있는 단점을 보완하기 때문에 가장 좋은 모델에 가까운 모델을 얻을 수 있는 방법이라고 생각하며, R에서 사용하는 것을 추천드립니다.
출처입니다~ 자세한 내용은 밑에 기사에서 확인해주세요^^
‘삼성 AI 포럼 2019’ 기술 한계 극복을 위해 글로벌 전문가 한 자리에
삼성전자는 AI 기술의 무한한 가능성에 주목하고, 이를 통해 더 나은 미래를 실현하고자 다양한 시도를 하고 있다. 이 같은 노력의 일환으로 지난 4일과 5일 서초사옥 다목적홀과 서울 R&D 캠퍼스에서 ‘삼성 AI 포럼 2019’가 진행됐다. 올해로 3회차를 맞은 ‘삼성 AI
news.samsung.com
내용요약
최근 AI 기술은 특정 알고리즘에 따라 주어진 데이터를 단순히 연산하는 것에 그치지 않고, 인간처럼 사고하고 행동하는 수준에 가까워지고 있습니다.
빅데이터가 확보되어, 딥러닝 기술과 AI의 발전을 과속화 시키고 있습니다.
AI전문가들에 의하면 기술 발전이 다음 단계로 넘어가기 위해서는
1. 알고리즘 효율화
2. 시스템 구축 비용 절감
3. 데이터 학습방식 개선
등을 꼽았습니다.
또한 미래 AI 기술의 방향성은
1. 무선 네트워크 제어
2. AI 자율성 증대
3. 적용 분야 확대
등을 제시했습니다.
GAN(Generative Adversarial Network, 생성적 적대 신경망)
생성적 적대 신경망(GAN)이란 두개의 네트워크로 구성된 심층 신경망 구조입니다. 최대한 진짜 같은 데이터를 생성하려는 생성 모델(generator)과 진짜와 가짜를 판별하려는 분류 모델(discriminator)이 각각 존재하여 서로 적대적으로 학습합니다.
GAN은 다음과 같은 동작으로 이루어집니다.
- 생성 모델이 임의의 수를 입력받아 생성한 이미지로 반환합니다.
- 이렇게 생성된 이미지와 실제 데이터 세트에서 가져온 이미지들을 분류 모델에 전달합니다.
- 분류모델에서는 실제 이미지와 가짜 이미지를 판별해 0과 1사이의 확률값으로 반환시킵니다.
( 1 : 실제 이미지, 0 : 가짜 이미지)
RNN(Recurrent Neural Network, 순환 신경망)
순환 인공 신경망(RNN)은 유닛간의 연결이 순환적 구조를 갖는 특징을 갖는 인공 신경망입니다.
이러한 구조를 가지고 있기 때문에 시계열 데이터와 같이 시간의 흐름에 따라 변화하는 데이터를 학습시킬 수 있습니다.
순환 신경망의 대표적인 예는 글자나 문장을 완성해주는 알고리즘입니다. 문장 데이터의 경우에 앞 뒤 데이터간의 연관성을 가지고 있습니다. 예를 들어, '안','녕','하' 다음에 나올 글자는 '세'일 확률이 크며, 그 다음으로 '요'가 나올 확률이 큽니다. 이렇게 RNN은 앞 뒤의 데이터 간에 연관성이 있는 데이터셋에 사용될 수 있습니다. 또한 필기체 인식이나 음성 인식과 같이 시변적 특징을 가지는 데이터를 처리할 때 사용할 수 있습니다.
GNN(Graph Neural Network)
GNN은 그래프 구조에서 사용하는 인공 신경망입니다. CNN이나 RNN 등의 인공 신경망들은 보통 벡터나 행렬 형태로 input이 주어지는데 반해서 GNN의 경우에는 input이 그래프 구조라는 특징을 가지고 있습니다.
'기타 > IT 관련 뉴스 기사수집' 카테고리의 다른 글
| BNK·DGB·JB금융, 빅데이터 플랫폼 구축…‘디지털 전환’ 가속 (0) | 2020.05.20 |
|---|---|
| AI튜터 출시, AI기술로 영어 공부 (0) | 2019.11.13 |
| 연주자 감성까지 반영하는 '음악AI'연구 (0) | 2019.11.11 |
| 대학생에게 홈쇼핑 데이터를 주면 매출을 예측할 수 있을까? (0) | 2019.11.08 |
| 더존비즈온, '위하고' 기반으로 이커머스 사업 진출 (0) | 2019.11.07 |