[빅데이터분석] Python_55. 판다스 머신러닝5.(랜덤 포레스트 , 수치예측)

📝 파이썬으로 랜덤 포레스트 모델 생성해서 수치 예측하기 ( 빅분기 실기 2유형 )

• 처음에는 회귀트리 모델로 수치예측 → 랜덤 포레스트 모델로 수치 예측

#1. 데이터 로드
import pandas  as  pd
wine = pd.read_csv("c:\\data\\whitewines.csv")
#wine.head()

#2. 결측치 확인
wine.isnull().sum()

# 3. 훈련과 테스트 분리
from sklearn.model_selection import train_test_split

x = wine.iloc[: , 0:-1] #맨 끝의 컬럼인 quality를 제외
y = wine.iloc[: , -1] # 맨 끝의 정답 데이터

x_train, x_test, y_train, y_test = train_test_split(x,y, test_size=0.1, random_state=1)

#print(x_train.shape) (4408, 11)
#print(x_test.shape) (490, 11)
#print(y_train.shape) (4408,)
#print(y_test.shape) (490,)

# 4. 모델 생성(수치를 예측하는 의사결정 나무 생성 --> 회귀트리) 
from sklearn.tree import DecisionTreeRegressor

model = DecisionTreeRegressor(random_state = 1)
model

# 5. 모델 훈련
model.fit(x_train, y_train)

# 6. 모델 예측
result = model.predict(x_test)
result 

# 7. 모델 평가 (상관계수, 오차 확인)
# 정답과 예측과의 상관계수
import numpy as np 
np.corrcoef(y_test,result) # 0.58180875

#정답과 예측과의 오차확인
def mae(x,y):
    return np.mean(abs(x-y))
print(mae(y_test, result)) # 0.47551020408163264

# 8. 모델 개선
# 기존모델 : 의사결정 트리 회귀모델 (from sklearn.tree import DecisionTreeRegressor)
# 개선모델 : 앙상블을 이용한 의사결정트리 회귀모델 (from sklearn.ensemble import RandomForestRegressor)

from sklearn.ensemble import RandomForestRegressor

model2 = RandomForestRegressor(random_state = 1)
model2

model2.fit(x_train, y_train)

result2 = model2.predict(x_test)
result2 

# 정답과 예측과의 상관계수
import numpy as np 
np.corrcoef(y_test,result2) 
print( np.corrcoef( y_test, result2 )  ) # 0.71178998
#정답과 예측과의 오차확인
def mae(x,y):
    return np.mean(abs(x-y))
print(mae(y_test, result2)) # 0.43489795918367347

 

문제1. 랜덤 포레스트 회귀 모델의 나무 갯수를 늘려서 성능을 올리기
- 힌트 : model2 = RandomForestRegressor(random_state =1, n_estimators=100)

# 8. 모델 개선
# 기존모델 : 의사결정 트리 회귀모델 (from sklearn.tree import DecisionTreeRegressor)
# 개선모델 : 앙상블을 이용한 의사결정트리 회귀모델 (from sklearn.ensemble import RandomForestRegressor)

from sklearn.ensemble import RandomForestRegressor

model2 = RandomForestRegressor(random_state =1, n_estimators=100)
model2

model2.fit(x_train, y_train)

result2 = model2.predict(x_test)
result2 

# 정답과 예측과의 상관계수
import numpy as np 
np.corrcoef(y_test,result2) 
print( np.corrcoef( y_test, result2 )  ) # 0.71178998
#정답과 예측과의 오차확인
def mae(x,y):
    return np.mean(abs(x-y))
print(mae(y_test, result2)) # 0.43489795918367347​

n_estimatiors 를 더 늘려도 성능이 개선되지 않는다면?

모델을 바꾸거나 파생변수를 추가 또는 정규화 여부를 고려해봐야함

문제2. 최대 최소 정규화를 진행해서 더 성능을 올리기
- 훈련 데이터와 테스트 데이터를 분리한 후에 최대 최소 정규화를 진행하는데,
- 훈련 데이터에 대해서 최대 최소 정규화를 진행하고
- 훈련 데이터에 대해서 최대 최소 정규화한 계산한 것을 가지고
- 테스트 데이터에 대해서 최대 최소 정규화를 진행

#1. 데이터 로드
import pandas  as  pd
wine = pd.read_csv("c:\\data\\whitewines.csv")
wine.head()

#2. 결측치 확인
wine.isnull().sum()


#3. 훈련과 테스트 분리
from sklearn.model_selection  import  train_test_split

x = wine.iloc[ :  , 0:-1]   # 맨끝의 컬럼인 quality 를 제외
y = wine.iloc[ :  , -1 ]    # 맨끝의 정답 데이터

x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.1, random_state=1)

# print( x_train.shape )
# print( x_test.shape )
# print( y_train.shape )
# print( y_test.shape )

# 훈련 데이터와 테스트 데이터에 대해서 최대 최소 정규화를 수행
from  sklearn.preprocessing  import  MinMaxScaler

scaler = MinMaxScaler()

x_train2 = scaler.fit_transform(x_train)
x_test2 = scaler.transform(x_test)


#4. 개선 모델 생성( 수치를 예측하는 의사결정 나무 생성--> 회귀트리 )
from  sklearn.ensemble   import  RandomForestRegressor

model2 = RandomForestRegressor(random_state =10, n_estimators=200 )
model2

#5. 개선 모델 훈련
model2.fit( x_train2, y_train)

#6. 개선 모델 예측
result2 = model2.predict(x_test2)
result2

#7. 개선 모델 평가 (상관계수, 오차 확인)

#정답과 예측과의 상관계수 
import  numpy  as  np 

print( np.corrcoef( y_test, result2 )  )  #  0.71304028

#정답과 예측과의 오차확인
def  mae(x,y):
    return  np.mean(abs(x-y))

print( mae(y_test, result2 ) )  #  0.71304028​

시험 볼때는 : 랜덤 포레스트 회귀 모델 쓰면 됨

케글 도전할 때는 : 랜덤 포레스트, 서포트 백터 머신, 신경망 모델로 다양하게 사용

처음에 모델 생성 → 개선된 모델 생성했을 때 개선이 있었다면 그걸 스토리를 잘 만들어서 포트폴리오를 생성하면 됨

문제3. 서포트 벡터 머신 모델로 변경해서 모델을 생성하기
개선 모델 :
from sklearn.svm import SVC
model4 = SVC(C=200, gamma=

#1. 데이터 로드
import pandas  as  pd
wine = pd.read_csv("c:\\data\\whitewines.csv")
wine.head()

#2. 결측치 확인
wine.isnull().sum()


#3. 훈련과 테스트 분리
from sklearn.model_selection  import  train_test_split

x = wine.iloc[ :  , 0:-1]   # 맨끝의 컬럼인 quality 를 제외
y = wine.iloc[ :  , -1 ]    # 맨끝의 정답 데이터

x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.1, random_state=1)

# print( x_train.shape )
# print( x_test.shape )
# print( y_train.shape )
# print( y_test.shape )

# 훈련 데이터와 테스트 데이터에 대해서 최대 최소 정규화를 수행
from  sklearn.preprocessing  import  MinMaxScaler

scaler = MinMaxScaler()

x_train2 = scaler.fit_transform(x_train)
x_test2 = scaler.transform(x_test)


#4. 개선 모델 생성( 수치를 예측하는 의사결정 나무 생성--> 회귀트리 )
from sklearn.svm import SVC

model4 = SVC(gamma = 3, C = 200)
model4

#5. 개선 모델 훈련
model4.fit( x_train2, y_train)

#6. 개선 모델 예측
result2 = model4.predict(x_test2)
result2

#7. 개선 모델 평가 (상관계수, 오차 확인)

#정답과 예측과의 상관계수 
import  numpy  as  np 

print( np.corrcoef( y_test, result2 )  )  # 0.46067544

#정답과 예측과의 오차확인
def  mae(x,y):
    return  np.mean(abs(x-y))

print( mae(y_test, result2 ) )  # 0.5428571428571428​

0.46067544 ← 상관계수가 더 떨어졌음

현장에서도 마감날짜가 있으므로 성능 개선에 너무 많은 시간을 쏟지 말고, 발표자료에 모델별 성능을 표로 정리를 해서 제출 ( 선택은 고객이 할 수 있도록 함)

문제4. 신경망으로 수치를 예측하기
개선모델 :
from sklearn.neural_network import MLPRegressor
model5 = MLPRegressor(random_state =1, hidden_layer_sizes=(200,50) )

#1. 데이터 로드
import pandas  as  pd
wine = pd.read_csv("c:\\data\\whitewines.csv")
wine.head()

#2. 결측치 확인
wine.isnull().sum()


#3. 훈련과 테스트 분리
from sklearn.model_selection  import  train_test_split

x = wine.iloc[ :  , 0:-1]   # 맨끝의 컬럼인 quality 를 제외
y = wine.iloc[ :  , -1 ]    # 맨끝의 정답 데이터

x_train, x_test, y_train, y_test = train_test_split( x, y, test_size=0.1, random_state=1)

# print( x_train.shape )
# print( x_test.shape )
# print( y_train.shape )
# print( y_test.shape )

# 훈련 데이터와 테스트 데이터에 대해서 최대 최소 정규화를 수행
from  sklearn.preprocessing  import  MinMaxScaler

scaler = MinMaxScaler()

x_train2 = scaler.fit_transform(x_train)
x_test2 = scaler.transform(x_test)


#4. 개선 모델 생성( 수치를 예측하는 의사결정 나무 생성--> 회귀트리 )
from sklearn.neural_network  import  MLPRegressor

model5 =  MLPRegressor(random_state =1, hidden_layer_sizes=(200,50) )

#5. 개선 모델 훈련
model5.fit( x_train2, y_train)

#6. 개선 모델 예측
result2 = model5.predict(x_test2)
result2

#7. 개선 모델 평가 (상관계수, 오차 확인)

#정답과 예측과의 상관계수 
import  numpy  as  np 

print( np.corrcoef( y_test, result2 )  )  # 0.57334932

#정답과 예측과의 오차확인
def  mae(x,y):
    return  np.mean(abs(x-y))

print( mae(y_test, result2 ) )  #0.5769286331025102​

실험결과를 표로 생성:

                                                           상관계수                    오차

1. 랜덤 포레스트 모델 0.71
2. 서포트 백터 머신 모델 0.51
3. 신경망 모델 0.57

📝빅분기 실기 2회 시험 작업형 2번 환경 만들기

# 데이터 만들기

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

# 가상 데이터 생성 (정답이 명확히 구분되는 단순한 패턴)
np.random.seed(42)
n_samples = 1000

# 학습 데이터 생성
X = pd.DataFrame({
    'cust_id': range(1, n_samples + 1),
    'Age': np.random.randint(18, 70, size=n_samples),
    'Income': np.random.randint(30000, 120000, size=n_samples),
    'Previous_Purchases': np.random.randint(0, 20, size=n_samples),
    'Web_Visits': np.random.randint(1, 100, size=n_samples)
})

# 구매 여부는 단순히 이전 구매 횟수가 10 이상인 경우로 가정하여 y 생성
y = (X['Previous_Purchases'] >= 10).astype(int)

# y를 데이터프레임으로 변환
y = pd.Series(y, name='Purchased')

# 데이터 크기 확인 (디버깅 목적)
print(f"X 데이터 크기: {X.shape}")
print(f"y 데이터 크기: {y.shape}")

# ■ 시험환경 만들기. 훈련 데이터와 테스트 데이터를 생성합니다.

# 훈련 데이터와 테스트 데이터를 분리합니다.
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

# 만든 데이터를 시험환경에 저장합니다. (폴더 생성도 해주기!)
x_train.to_csv("c:\\data\\test2\\X_train.csv", index=False)
y_train.to_csv("c:\\data\\test2\\y_train.csv", index=False)
x_test.to_csv("c:\\data\\test2\\X_test.csv", index=False)​

 

⭐빅분기 3회 작업형2번 문제. 특정 여행객 데이터 셋을 바탕으로 여행 보험 상품 가입 여부를 예측하는 분류 모델을 생성하기 . 모델은 주어진 데이터를 학습하고 테스트 데이터를 사용하여 예측할 것

- 숫자와 문자 같이 있는 유형 풀

#1. 데이터 생성 
import pandas as pd
import numpy as np

# ▣ 시험환경 만들기 1. 여행보험 예측을 위한 가상 데이터 생성

# 가상 데이터 생성
np.random.seed(42)
n_train_samples = 1490
n_test_samples = 497

# 훈련 데이터 생성
x_train = pd.DataFrame({
    'index': range(1, n_train_samples + 1),
    'Age': np.random.randint(18, 70, size=n_train_samples),
    'Income': np.random.randint(30000, 120000, size=n_train_samples),
    'Marital_Status': np.random.choice(['Single', 'Married'], n_train_samples),
    'Employment_Type': np.random.choice(['Employed', 'Self-Employed', 'Unemployed'], n_train_samples),
    'Previous_Claims': np.random.randint(0, 10, size=n_train_samples),
    'Family_Size': np.random.randint(1, 7, size=n_train_samples),
    'Travel_History': np.random.choice(['Frequent', 'Occasional', 'Rare'], n_train_samples),
    'Destination_Type': np.random.choice(['Domestic', 'International'], n_train_samples),
    'Flight_Class': np.random.choice(['Economy', 'Business'], n_train_samples)
})

# 여행보험 가입 여부 (약 7:3 비율)
y_train = pd.Series(np.random.choice([0, 1], size=n_train_samples, p=[0.7, 0.3]), name='Travel_Insurance')

# 테스트 데이터 생성
x_test = pd.DataFrame({
    'index': range(n_train_samples + 1, n_train_samples + n_test_samples + 1),
    'Age': np.random.randint(18, 70, size=n_test_samples),
    'Income': np.random.randint(30000, 120000, size=n_test_samples),
    'Marital_Status': np.random.choice(['Single', 'Married'], n_test_samples),
    'Employment_Type': np.random.choice(['Employed', 'Self-Employed', 'Unemployed'], n_test_samples),
    'Previous_Claims': np.random.randint(0, 10, size=n_test_samples),
    'Family_Size': np.random.randint(1, 7, size=n_test_samples),
    'Travel_History': np.random.choice(['Frequent', 'Occasional', 'Rare'], n_test_samples),
    'Destination_Type': np.random.choice(['Domestic', 'International'], n_test_samples),
    'Flight_Class': np.random.choice(['Economy', 'Business'], n_test_samples)
})

# CSV 파일로 저장
x_train.to_csv('c:\\data\\test3\\train_data.csv', index=False)
y_train.to_csv('c:\\data\\test3\\y_train.csv', index=False)
x_test.to_csv('c:\\data\\test3\\test_data.csv', index=False)​

#1. 데이터 불러오기
X_train = pd.read_csv('c:\\data\\test3\\train_data.csv')
y_train = pd.read_csv('c:\\data\\test3\\y_train.csv')
X_test = pd.read_csv('c:\\data\\test3\\test_data.csv')

#2. 'index' 컬럼 제거
X_train2 = X_train.drop(columns=['index'])
X_test2 = X_test.drop(columns=['index'])
X_train2.head(5)


#3. 문자형 컬럼을 숫자로 변환합니다.    
# ※ 파이썬은 R 과는 다르게 문자형을 숫자형으로 변환해주는 작업을 해줘야합니다. 

# 문자를 숫자로 바꾸는 파이썬 함수 2개 ?
# 1.  pd.get_dummies(x)
# 2.  LabelEncoder()  

from  sklearn.preprocessing import  MinMaxScaler, LabelEncoder 

for  i  in X_train2.select_dtypes( include=['object'] ).columns:
    le = LabelEncoder()
    X_train2[i] = le.fit_transform(X_train2[i])
    X_test2[i] = le.fit_transform(X_test2[i])

#4. 데이터를 정규화합니다.
scaler = MinMaxScaler()
x_train3 = scaler.fit_transform(X_train2)
x_test3 = scaler.fit_transform(X_test2)
#print(x_train3)

#5. 모델 생성
from  sklearn.ensemble  import  RandomForestClassifier 

model = RandomForestClassifier(random_state=1)

#6. 모델  훈련
model.fit( x_train3, y_train )

#7. 모델 예측
pred = model.predict( x_test3 )

#8. 정답 제출
pd.DataFrame( {'index' : X_test.index, 'label' : pred }).to_csv('003000.csv', index=False)

#9. 모델 평가
from  sklearn.metrics  import  accuracy_score

y_hat = model.predict(x_train3)

accuracy_score( y_hat, y_train ) #1.0

 

📝빅분기 실기 기출문제_4회 작업형 2번

# 데이터 만들기

# 데이터 생성하기
import pandas as pd
import numpy as np

# ▣ 시험환경 만들기 1. 세분화 시장 예측을 위한 가상 데이터 생성

# 가상 데이터 생성
np.random.seed(42)
n_train_samples = 1000
n_test_samples = 300

# 훈련 데이터 생성
X_train = pd.DataFrame({
    'ID': range(1, n_train_samples + 1),
    'Age': np.random.randint(18, 70, size=n_train_samples),
    'Income': np.random.randint(30000, 120000, size=n_train_samples),
    'Car_Ownership_Years': np.random.randint(1, 15, size=n_train_samples),
    'Annual_Spend': np.random.randint(10000, 50000, size=n_train_samples)
})

# Segmentation (1, 2, 3, 4) 라벨 생성
y_train = pd.Series(np.random.choice([1, 2, 3, 4], size=n_train_samples), name='Segmentation')

# 테스트 데이터 생성
X_test = pd.DataFrame({
    'ID': range(n_train_samples + 1, n_train_samples + n_test_samples + 1),
    'Age': np.random.randint(18, 70, size=n_test_samples),
    'Income': np.random.randint(30000, 120000, size=n_test_samples),
    'Car_Ownership_Years': np.random.randint(1, 15, size=n_test_samples),
    'Annual_Spend': np.random.randint(10000, 50000, size=n_test_samples)
})

# CSV 파일로 저장
X_train.to_csv('c:\\data\\test4\\train.csv', index=False)
y_train.to_csv('c:\\data\\test4\\y_train.csv', index=False)
X_test.to_csv('c:\\data\\test4\\test.csv', index=False)

문제. 한 자동차 회사는 새로운 마케팅 전략을 수립하기 위해 고객을 4개의 세분화된 시작으로 나누었음. 기존 고객 데이터를 바타응로 신규고객이 어떤 세분화된 시장(segmentation: 1,2,3,4) 에 속할지 예측하는 모델을 구축하기

#1. 데이터 불러오기
import pandas as pd

x_train = pd.read_csv("c:\\data\\test4\\train.csv")
y_train = pd.read_csv("c:\\data\\test4\\y_train.csv")
x_test = pd.read_csv("c:\\data\\test4\\test.csv")

print(x_train.shape) #(1000, 5)
print(x_test.shape) #(300, 5)
print(y_train.shape) #(1000, 1)
x_train.head(10)
#y_train.head(5)

#2. id 컬럼 제거해서 정규화하기

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
scaler.fit(x_train.drop(columns=['ID'])) #정규화 계산 수행

x_train2 = scaler.transform(x_train.drop(columns=['ID'])) #훈련 데이터 정규화 수행
x_test2 = scaler.transform(x_test.drop(columns=['ID'])) #테스트 데이터 정규화 수행

#3. 모델 생성하기 
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()

#4. 모델 훈련 
model.fit(x_train2, y_train)

#5. 모델 예측
pred = model.predict(x_test2)

#6. 정답 제출
pd.DataFrame( {'ID': x_test.ID, 'label' : pred}).to_csv('수험번호.csv',index=False)

#7. 모델 평가(훈련 데이터)
from sklearn.metrics import accuracy_score
y_hat = model.predict(x_train2)
accuracy_score(y_hat,y_train) #1.0

 

📝빅분기 실기 기출문제_5회 작업형 2번

# 데이터 만들기
import pandas as pd
import numpy as np

# ▣ 시험환경 만들기1. 수리 비용 예측을 위한 가상 데이터 생성

# 가상 데이터 생성
np.random.seed(42)
n_samples = 1000

# 학습 데이터 생성
X = pd.DataFrame({
    'device_id': range(1, n_samples + 1),
    'year': np.random.randint(2010, 2022, size=n_samples),        # 제조연도
    'usage_hours': np.random.randint(100, 10000, size=n_samples), # 사용시간
    'warranty': np.random.randint(1, 5, size=n_samples),          # 보증기간 (연도)
    'battery_life': np.random.randint(50, 100, size=n_samples),   # 배터리 수명 (%)
    'storage_capacity': np.random.randint(32, 1024, size=n_samples) # 저장 용량 (GB)
})

# 수리 비용은 사용시간과 보증기간을 기반으로 예측
y = (X['usage_hours'] / 100) + (X['storage_capacity'] / 10) - (X['warranty'] * 50)

# y를 데이터프레임으로 변환
y = pd.Series(y, name='repair_cost')

# 데이터 크기 확인 (디버깅 목적)
print(f"X 데이터 크기: {X.shape}")
print(f"y 데이터 크기: {y.shape}")

# ■ 시험환경 만들기2. 훈련 데이터와 테스트 데이터를 생성합니다.

# 훈련 데이터와 테스트 데이터를 분리합니다.
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

# 만든 데이터를 시험환경에 저장합니다.
x_train.to_csv("X_train.csv", index=False)
y_train.to_csv("y_train.csv", index=False)
x_test.to_csv("X_test.csv", index=False)

 

📝빅분기 실기 기출문제 6 작업형 2번

# 훈련 데이터 만들기

import pandas as pd
import numpy as np

# 가상 데이터 생성
np.random.seed(42)
n_samples = 1000

# 학습 데이터 생성
data = {
    'car_id': range(1, n_samples + 1),
    '차량_연식': np.random.randint(2000, 2021, n_samples),
    '주행거리': np.random.randint(5000, 200000, n_samples),
    '연료비': np.random.randint(50, 200, n_samples),
    '엔진 크기': np.random.randint(1000, 4000, n_samples),
    '연비': np.random.choice([0, 1], n_samples, p=[0.7, 0.3])  # 연비가 1이면 경제적인 차량, 0이면 비경제적인 차량
}

df = pd.DataFrame(data)

# CSV 파일로 저장
df.to_csv('c:\\data\\test6\\car_train.csv', index=False)

# 테스트 데이터 만들기
import pandas as pd
import numpy as np

# 가상 테스트 데이터 생성
np.random.seed(42)
n_samples = 500  # 테스트 데이터 샘플 개수

# 학습 데이터와 같은 형태의 테스트 데이터 생성 (단, '연비' 열 제외)
test_data = {
    'car_id': range(1, n_samples + 1),
    '차량_연식': np.random.randint(2000, 2021, n_samples),
    '주행거리': np.random.randint(5000, 200000, n_samples),
    '연료비': np.random.randint(50, 200, n_samples),
    '엔진 크기': np.random.randint(1000, 4000, n_samples)
}

df_test = pd.DataFrame(test_data)

# CSV 파일로 저장 (정답 없이)
df_test.to_csv('c:\\data\\test6\\car_test.csv', index=False)

 

#1. 데이터 불러오기
import pandas as pd

df = pd.read_csv("c:\\data\\test6\\car_train.csv")
x_train = df.iloc[ : , 0:5]
y_train = df.iloc[ : , 5]
x_test = pd.read_csv("c:\\data\\test6\\car_test.csv")
 
#2. 데이터 살펴보기
x_train.isnull().sum()

#3. 데이터 정규화
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
x_train2 = scaler.fit_transform(x_train)
x_test2 = scaler.transform(x_test)

#4. 모델생성
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=1)

#5. 모델 훈련
model.fit(x_train2, y_train)

#6. 모델 예측
result = model.predict(x_test2)
result 

#7. 정답 제출
pd.DataFrame({'car_id' : x_test['car_id'],'pred' : result})
#pd.DataFrame({'car_id' : x_test['car_id'],'pred' : result}).to_csv("수험번호.csv", index = False)

#8. 모델 평가
from sklearn.metrics import accuracy_score
y_hat = model.predict(x_train2)
accuracy_score(y_hat, y_train)

 

📝빅분기 실기 7 작업형 2번 (수치예측)

# 데이터 만들기

import pandas as pd
import numpy as np

# 가상 데이터 생성
np.random.seed(42)
n_samples_train = 1000
n_samples_test = 300

# 훈련 데이터 생성
X_train = pd.DataFrame({
    'part_id': range(1, n_samples_train + 1),
    'material_quality': np.random.uniform(0.5, 1.5, n_samples_train),
    'processing_time': np.random.uniform(20, 200, n_samples_train),
    'worker_experience': np.random.randint(1, 20, n_samples_train),
    'machine_efficiency': np.random.uniform(70, 100, n_samples_train),
    'temperature': np.random.uniform(60, 120, n_samples_train)
})

y_train = X_train['material_quality'] * X_train['processing_time'] * 0.05 + \
          X_train['worker_experience'] * 0.1 + \
          X_train['machine_efficiency'] * 0.2 + \
          X_train['temperature'] * 0.05 + np.random.normal(0, 5, n_samples_train)

y_train = pd.Series(np.round(y_train), name='total_production')

# 테스트 데이터 생성
X_test = pd.DataFrame({
    'part_id': range(n_samples_train + 1, n_samples_train + n_samples_test + 1),
    'material_quality': np.random.uniform(0.5, 1.5, n_samples_test),
    'processing_time': np.random.uniform(20, 200, n_samples_test),
    'worker_experience': np.random.randint(1, 20, n_samples_test),
    'machine_efficiency': np.random.uniform(70, 100, n_samples_test),
    'temperature': np.random.uniform(60, 120, n_samples_test)
})

# CSV 파일로 저장
X_train.to_csv("c:\\data\\test7\\auto_train.csv", index=False)
y_train.to_csv("c:\\data\\test7\y_train.csv", index=False)
X_test.to_csv("c:\\data\\test7\\auto_test.csv", index=False)

오늘의 마지막 문제. 자동차 부품 제조 회사는 부품 생산량을 예측하기 위해서 다양한 데이터를 수집했음 . 주어진 데이터는 각 부품의 특성과 생산 공정 데이터를 포함하고 있으며, 이를 바탕으로 부품의 총 생산량을 예측하는 모델을 개발하고자함

#1. 데이터 불러오기
import pandas as pd

x_train = pd.read_csv("c:\\data\\test7\\auto_train.csv")
y_train = pd.read_csv("c:\\data\\test7\y_train.csv")
x_test = pd.read_csv("c:\\data\\test7\\auto_test.csv")

x_train.head()

#2. 데이터 정규화
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
x_train2 = scaler.fit_transform(x_train.drop(columns=['part_id']))
x_test2 = scaler.transform(x_test.drop(columns=['part_id']))
#print(x_train2)

#3. 모델 생성
from sklearn.ensemble import RandomForestRegressor
model =  RandomForestRegressor()

#4. 모델 훈련
model.fit(x_train2, y_train)

#5. 모델 예측 
pred = model.predict(x_test2)
pred

#6. 정답 제출
pd.DataFrame({'part_id':x_test['part_id'],'label':pred})
#pd.DataFrame({'part_id':x_test['part_id'],'label':pred}).to_csv("수험번호.csv",index=False)

#7. 모델 평가 (상관관계)
import numpy as np
y_hat = model.predict(x_train2)
np.corrcoef(y_hat, y_train.to_numpy().flatten()) #0.96