😢 스터디노트 (Machine Learning 14)

네이버 책 가격 회귀분석

# API 이용

import urllib.request

client_id = '<개인 id>'
client_secret = '<개인 secret>'

# url 만드는 함수

def gen_search_url(api_node, search_text, start_num, disp_num):
    base = 'https://openapi.naver.com/v1/search'
    node = '/' + api_node + '.json'
    param_query = '?query=' + urllib.parse.quote(search_text)
    param_start = '&start=' + str(start_num)
    param_disp = '&display=' + str(disp_num)
    
    return base + node + param_query + param_start + param_disp

gen_search_url('book', '파이썬', 10, 3)

# page에서 정보 얻기

import json
import datetime

def get_result_onpage(url):
    request = urllib.request.Request(url)
    request.add_header('X-Naver-Client-Id', client_id)
    request.add_header('X-Naver-Client-Secret', client_secret)
    
    response = urllib.request.urlopen(request)
    
    print('[%s] Url Request Success' % datetime.datetime.now())
    
    return json.loads(response.read().decode('utf-8'))

url = gen_search_url('book', '파이썬', 10, 3)
one_result = get_result_onpage(url)

one_result

# 제목에서 tag 제거

def delete_tag(input_str):
    input_str = input_str.replace('<b>', '')
    input_str = input_str.replace('</b>', '')
    
    return input_str

# 한 페이지의 내용을 pandas에

import pandas as pd

def get_fields(json_data):
    title = [delete_tag(each['title']) for each in json_data['items']]
    link = [each['link'] for each in json_data['items']]
    price = [each['discount'] for each in json_data['items']]
    publisher = [each['publisher'] for each in json_data['items']]
    isbn = [each['isbn'] for each in json_data['items']]
    
    result_pd = pd.DataFrame({'title':title, 'price':price, 'isbn':isbn, 'link':link, 
                              'publisher':publisher}, columns=['title','price','publisher','isbn','link'])
    return result_pd
    

# 간단 테스트

url = gen_search_url('book', '파이썬', 10, 3)
json_result = get_result_onpage(url)
pd_result = get_fields(json_result)
pd_result

# API를 이용한 정보 수집 1000개

result_book = []

for n in range(1, 1000, 10):
    url = gen_search_url('book', '파이썬', n, 100)
    json_result = get_result_onpage(url)
    pd_result = get_fields(json_result)
    
    result_book.append(pd_result)
    
result_book = pd.concat(result_book)

# 인덱스 정리

result_book.reset_index(drop=True, inplace=True)
result_book.info()

# 가격의 데이터형 정리

result_book['price'] = result_book['price'].astype('float')
result_book.info()

# 한 페이지에 대해 일단 테스트

from bs4 import BeautifulSoup
from urllib.request import urlopen

url = 'https://search.shopping.naver.com/book/catalog/32456895000'
page = urlopen(url)

soup = BeautifulSoup(page, 'html.parser')
soup

soup.find_all(class_ = 'bookBasicInfo_spec__qmQ_N')[0].text

# re

import re

tmp = soup.find_all(class_ = 'bookBasicInfo_spec__qmQ_N')[0].get_text()
result = tmp

# result = re.search('페이지\s+\d+', tmp) 
# result.split()
# 지금과 맞지 않음


result

# 페이지 정보 얻기

import re
import numpy as np
import time

def get_page_num(soup):
    #time.sleep(1)
    tmp = soup.find_all('span', 'bookBasicInfo_spec__qmQ_N')[0].get_text()
    
    
    # url에 들어갔는데 페이지 정보가 없을 경우
    try: 
        #result = re.search('페이지\s+\d+', tmp).group()
        #result = tmp.split()[1]
        # 지금과 맞지 않음
        
        result = tmp      
        return result
    except:
        print('==> Error in get_page_num!')
        return np.nan

get_page_num(soup)

# 놓친 데이터도 존재한다

result_book.info()

# 데이터형 정리
result_book['page_num'] = result_book['page_num'].str.replace('쪽','')
result_book['page_num'] = result_book['page_num'].astype('float')
result_book.info()

# 놓친 데이터 다시 시도

for idx, row in result_book.iterrows():
    if np.isnan(row['page_num']):
        print('start fix...')
        print(row['link'])
        page_num = get_page_num(BeautifulSoup(urlopen(row['link']), 'html.parser'))
        
        result_book.loc[idx, 'page_num'] = page_num
        time.sleep(0.5)

# 다시 데이터형 정리

try:
    result_book['page_num'] = result_book['page_num'].str.replace('쪽','')
    result_book['page_num'] = result_book['page_num'].astype('float')
    result_book.info()
except:
    pass

# 페이지 정보 없는 것은 제외

result_book = result_book[result_book['page_num'].notnull()]
result_book.info()

# 엑셀로 정리

writer = pd.ExcelWriter('./python_books.xlsx', engine='xlsxwriter')
result_book.to_excel(writer, sheet_name='Sheet1')

workbook = writer.book
worksheet = writer.sheets['Sheet1']
worksheet.set_column('A:A', 5)
worksheet.set_column('B:B', 60)
worksheet.set_column('C:C', 10)
worksheet.set_column('D:D', 15)
worksheet.set_column('E:E', 10)
worksheet.set_column('F:F', 50)

writer.save()

---

회귀분석 해보기

# 데이터 다시 읽기

raw_data = pd.read_excel('./python_books.xlsx', index_col=0)
raw_data.head()

# seaborn으로 살펴보기
# 페이지와 가격은 관계가 있다


import seaborn as sns
import matplotlib.pyplot as plt

%matplotlib inline

plt.figure(figsize=(12, 8))
sns.regplot(x='page_num', y='price', data=raw_data,)
plt.show()

# 특별히 비싼 책 확인

raw_data[raw_data['price']>140000]

# 출판사 별로 확인

raw_data['publisher'].value_counts()

# 출판사 수

len(raw_data['publisher'].unique())

# matplotlib 한글 대응

import matplotlib.pyplot as plt
import seaborn as sns
import platform
import warnings

from matplotlib import font_manager, rc

warnings.filterwarnings(action= 'ignore') # 경고 문구 무시

# matplotlib 한글깨짐 보완
# matplotlib inline
get_ipython().run_line_magic('matplotlib', 'inline')

path = 'C:/Windows/Fonts/malgun.ttf'

if platform.system() == 'Darwin': # mac일 경우 한글 설정
    rc('font', family = 'Arial Unicode MS')
elif platform.system() =='Windows' : # window일 경우 한글 설정
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family = font_name)
else:
    print('unknown system sorry')

# 출판사별 편중 존재

plt.figure(figsize=(15, 6))
sns.countplot(x='publisher', data= raw_data, palette='RdYlGn',
              order=raw_data['publisher'].value_counts().index)
plt.xticks(rotation=90)
plt.show()

raw_1 = raw_data[raw_data['publisher']=='에이콘출판']

plt.figure(figsize=(12, 8))
sns.regplot(x='page_num', y='price', data=raw_1)
plt.show()

# 출판사별

raw_2 = raw_data[raw_data['publisher']=='한빛미디어']

plt.figure(figsize=(12, 8))
sns.regplot(x='page_num', y='price', data=raw_2)
plt.show()

# 가격을 보다 잘 예측할 수 있을 것같다

raw_3 = raw_data[raw_data['publisher']=='비제이퍼블릭']

plt.figure(figsize=(12, 8))
sns.regplot(x='page_num', y='price', data=raw_2)
plt.show()

raw_4 = raw_data[raw_data['publisher']=='위키북스']

plt.figure(figsize=(12, 8))
sns.regplot(x='page_num', y='price', data=raw_2)
plt.show()

# box 그래프

import plotly.express as px

px.box(raw_data, y='price')

# 회귀 모델 구성을 위한 데이터 나누기

from sklearn.model_selection import train_test_split

X = raw_data['page_num'].values
y = raw_data['price'].values


X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

X_train = X_train.reshape(-1, 1)
X_test = X_test.reshape(-1, 1)

# 모델학습

from sklearn.linear_model import LinearRegression

reg = LinearRegression()
reg.fit(X_train, y_train)

# 에러 계산

from sklearn.metrics import mean_squared_error

pred_tr = reg.predict(X_train)
pred_test = reg.predict(X_test)

rmse_tr = (np.sqrt(mean_squared_error(y_train, pred_tr)))
rmse_test = (np.sqrt(mean_squared_error(y_test, pred_test)))

print('RMSE of Train Data : ', rmse_tr)
print('RMSE of Test Data : ', rmse_test)
# train 데이터에 이상치가 있고 test에 없을 경우 test데이터의 값이 더 작을 수 있다.

# 참값과 예측값

plt.scatter(y_test, pred_test)
plt.xlabel('Actual')
plt.ylabel('Predict')
plt.plot([0, 80000],[0, 80000], 'r')
plt.show()

# 이번엔 특정 출판사 것만

X = raw_1['page_num'].values
y = raw_1['price'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)

X_train = X_train.reshape(-1, 1)
X_test = X_test.reshape(-1, 1)

reg.fit(X_train, y_train)

# 출판사별 예측이 맞을 것같다

pred_tr = reg.predict(X_train)
pred_test = reg.predict(X_test)

rmse_tr = (np.sqrt(mean_squared_error(y_train, pred_tr)))
rmse_test = (np.sqrt(mean_squared_error(y_test, pred_test)))

print('RMSE of Train Data : ', rmse_tr)
print('RMSE of Teset Data : ', rmse_test)

# 분야별로 점검하지 못했지만 출판사별로는 의미가 있다

plt.scatter(y_test, pred_test)
plt.xlabel('Actual')
plt.ylabel('Predict')
plt.plot([0, 120000],[0, 120000], 'r')
plt.show()

💻 출처 : 제로베이스 데이터 취업 스쿨