<jupyter_start><jupyter_text>BÀI TẬP COLAB SỐ 03 - 17/05/2021PREDICT FINAL SCORE OF IT001---LỚP: CS114.L21NHÓM:1. <NAME> - *19520227*2. <NAME> - *19522450*3. <NAME> - *19521623*Nguồn tham khảo:* [Regularizing Linear Regression Models](https://blog.quantinsti.com/linear-regression-models-scikit-learn/)* [PolyminalFeatures](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html)Link data:* Data wecode: [link](https://raw.githubusercontent.com/lphuong304/CS114.L21/main/COLAB_ASSIGNMENTS/data%20IT001/wecode.csv)* Data score: [link](https://raw.githubusercontent.com/lphuong304/CS114.L21/main/COLAB_ASSIGNMENTS/data%20IT001/wecode.csv)References:1. [Import Packages and Discovery and Visualize Data](part1)2. [Pre-processing Data and Show the Correlation of the features](process)3. [Traning Model and Testing](model)4. [Nhận xét](nhanxet) 1. Import Packages Import Package and Discovery and Visualize Data  1.1 Import Packages<jupyter_code>import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn import svm, metrics
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.preprocessing import PolynomialFeatures
from sklearn.model_selection import train_test_split, KFold, cross_val_predict
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import  accuracy_score, mean_squared_error
import warnings
warnings.filterwarnings('ignore')
from imblearn.over_sampling import SMOTE, BorderlineSMOTE, SVMSMOTE, ADASYN<jupyter_output><empty_output><jupyter_text>1.2 Data Discovery<jupyter_code>data_score = pd.read_csv('https://raw.githubusercontent.com/lphuong304/CS114.L21/main/COLAB_ASSIGNMENTS/data%20IT001/score_training.csv')
data = pd.read_csv('https://raw.githubusercontent.com/lphuong304/CS114.L21/main/COLAB_ASSIGNMENTS/data%20IT001/wecode.csv')
data.head(5)
data.info()
#tries - tổng số lần nộp của mỗi user_id, tính luôn đã submit và chưa submit, cả những lần nộp bài full điểm cà chưa full điểm
raw = pd.DataFrame({'tries' : data['user_id'].value_counts()})
raw = raw.sort_index()
# solved - số problem đã giải được của mỗi user_id => is_final = 1 và pre-score = 10000
user_isfinal_score = data[['user_id', 'is_final', 'pre_score']]

solvedData = user_isfinal_score[(user_isfinal_score['is_final'] > 0) & (user_isfinal_score['pre_score'] == 10000)].groupby('user_id').sum()

solvedData.drop('pre_score', axis=1, inplace=True)
solvedData.rename(columns={'is_final':'solved'}, inplace=True)

raw = pd.concat([raw, solvedData], axis=1)
raw = raw.fillna(0.0)

#num_problemSumbited - tổng số problem đã sumbit cuối cùng của mỗi user_id trên tổng số lần thử, những bài submit có thể full điểm và không full điểm

# array of user_id
list_userID = data['user_id'].tolist()
listStr_userID = data['user_id'].astype(str).tolist()

# array of assignment_id
list_assignmentID = data['assignment_id'].astype(str).tolist()

# array of problem_id
list_problemID = data['problem_id'].astype(str).tolist()
list_problemID
# connect user-assignment-problem
for i in range(len(list_assignmentID)):
  list_assignmentID[i] = listStr_userID[i] + ' ' + list_assignmentID[i] + ' ' + list_problemID[i]

list_assignmentID
dictData = {'user_id': list_userID,
        'num_problemSubmitted': list_assignmentID}

num_problemSumbitedDF = pd.DataFrame(dictData).set_index('user_id')
num_problemSumbitedDF
num_problemSumbitedDF = num_problemSumbitedDF.groupby('user_id').nunique()

raw = pd.concat([raw, num_problemSumbitedDF], axis=1)

#tổng điểm các bài được cuối cùng của mỗi user
user_isfinal_score = data[['user_id', 'is_final', 'pre_score']]

trueScore = user_isfinal_score[user_isfinal_score['is_final'] > 0].groupby('user_id').sum()
trueScore = trueScore.drop('is_final', axis=1)
trueScore.rename(columns={'pre_score':'total_FinalScore'}, inplace=True)

raw = pd.concat([raw, trueScore], axis=1)
raw<jupyter_output><empty_output><jupyter_text>Giải thích ý nghĩa các features:* Tries: số lần mà user_id xuất hiện trên data, đồng nghĩa là tổng số lần thử giải các problem (tính luôn cả chưa submit, submit và AC, submit và không AC)* Solved: là số các problem được submit (is_final = 1, pre-score = 10000) của mỗi user_id đã được AC* Submitted: số lần user_id submit các problem (tính luôn cả những bài submit AC và chưa AC)* total_FinalScore: tổng điểm pre-score của user_id, tính luôn cả những bài đã AC và chưa AC.=>Từ các features các bạn gợi ý trên ms team và kinh nghiệm học môn NMLT - IT001 chúng em nhận thấy các features trên sẽ có khả năng cao phản ánh được năng lực của học sinh chính xác hơn các features khác, từ đó dự đoán điểm CK của các user_id.<jupyter_code>data_score['CK'] = pd.to_numeric(data_score['CK'], errors='coerce')
raw_ck = data_score['CK']<jupyter_output><empty_output><jupyter_text>1.3 Data Visualization<jupyter_code>fig= plt.figure(figsize = (20,21))
gs = fig.add_gridspec(5,5)
gs.update(wspace=0.4, hspace=0.4)

ax0 = fig.add_subplot(gs[0,0])
ax1 = fig.add_subplot(gs[0,1])
ax2 = fig.add_subplot(gs[1,0])
ax3 = fig.add_subplot(gs[1,1])
ax4 = fig.add_subplot(gs[2,0])
ax5 = fig.add_subplot(gs[2,1])
ax6 = fig.add_subplot(gs[3,0])
ax7 = fig.add_subplot(gs[3,1])
ax8 = fig.add_subplot(gs[4,0])
ax9 = fig.add_subplot(gs[4,1])
axes=[ax0,ax1,ax2,ax3,ax4,ax5, ax6, ax7, ax8, ax9]
background_color = '#f6f5f7'

for i in axes:
    i.set_facecolor(background_color)
fig.patch.set_facecolor(background_color) 
sns.kdeplot(ax = ax0, data=raw['tries'],shade=True,palette='rocket', label = 'tries') # Distributions
ax0.grid(linestyle='--', axis='y')
ax1.text(0.5,0.5,'Distribution of Tries',horizontalalignment = 'center',verticalalignment = 'center',fontsize = 18,fontfamily='serif')

fig.patch.set_facecolor(background_color) 
sns.kdeplot(ax= ax2, data=raw['solved'],shade=True,palette='rocket', label = 'solved') # Distributions
ax2.grid(linestyle='--', axis='y')
ax3.text(0.5,0.5,'Distribution of Solved',horizontalalignment = 'center',verticalalignment = 'center',fontsize = 18,fontfamily='serif')

fig.patch.set_facecolor(background_color) 
sns.kdeplot(ax = ax4, data=raw['num_problemSubmitted'],shade=True,palette='rocket', label = 'num_problemSubmitted') # Distributions
ax4.grid(linestyle='--', axis='y')
ax5.text(0.5,0.5,'Distribution of num_problemSubmitted',horizontalalignment = 'center',verticalalignment = 'center',fontsize = 18,fontfamily='serif')

fig.patch.set_facecolor(background_color) 
sns.kdeplot(ax= ax6, data= raw['total_FinalScore'],shade=True,palette='rocket', label = 'total_FinalScore') # Distributions
ax6.grid(linestyle='--', axis='y')
ax7.text(0.5,0.5,'Distribution of total_FinalScore',horizontalalignment = 'center',verticalalignment = 'center',fontsize = 18,fontfamily='serif')

fig.patch.set_facecolor(background_color) 
sns.kdeplot(ax= ax8, data = raw_ck,shade=True,palette='rocket', label = 'CK_Score') # Distributions
ax8.grid(linestyle='--', axis='y')
ax9.text(0.5,0.5,'Distribution of CK_Score',horizontalalignment = 'center',verticalalignment = 'center',fontsize = 18,fontfamily='serif')



axes1=[ax1,ax3,ax5,ax7,ax9]
for i in axes1:
    i.spines["bottom"].set_visible(False)
    i.spines["left"].set_visible(False)
    i.set_xlabel("")
    i.set_ylabel("")
    i.set_xticklabels([])
    i.set_yticklabels([])
    i.tick_params(left=False, bottom=False)
# removing spines of figures
for i in ["top","left","right"]:
    ax0.spines[i].set_visible(False)
    ax1.spines[i].set_visible(False)
    ax2.spines[i].set_visible(False)
    ax3.spines[i].set_visible(False)
    ax4.spines[i].set_visible(False)
    ax5.spines[i].set_visible(False)
    ax6.spines[i].set_visible(False)
    ax7.spines[i].set_visible(False)
    ax8.spines[i].set_visible(False)
    ax9.spines[i].set_visible(False)
fig=plt.figure(figsize=(20,23))
background_color = '#f6f5f7'
fig.patch.set_facecolor(background_color) 
data_categorical = pd.concat([data['is_final'], data['status']], axis=1)
for indx,val in enumerate(data_categorical.columns):
    ax=plt.subplot(4,2,indx+1)
    ax.set_facecolor(background_color)
    ax.set_title(val,fontweight='bold',fontfamily='serif')
    for i in ['top','right']:
        ax.spines[i].set_visible(False)
    ax.grid(linestyle=':',axis='y')
    sns.countplot(data_categorical[val],palette='rocket')<jupyter_output><empty_output><jupyter_text>Nhận xét dữ liệu:* Điểm CK có sự phân bố không đồng đều, điểm từ khoảng 5 - 8 chiếm tỉ lệ nhiều nhất, chúng em dự đoán có thể nếu sử dụng data như trên thì model sẽ không dự đoán tốt các học sinh có khung điểm từ  9 - 10, nên cân nhắc sẽ bổ sung data sau bằng phương pháp over-sampling.* Chỉ số Tries  trong khoảng từ 10 đến 300 là nhiều nhất, trong khi các problems được giải AC - solved phân phối nhiều trong khoảng từ 50 đến 150, xấp xỉ 1 nửa so với tries. Song song đó số bài hoàn thành bao gồm cả những bài không được AC - submitted thì có phân phối cao nhất trong khoảng từ 20 - 150* finalScore phân bố nhiều trong khoảng từ 5e5 đến 2e6.<jupyter_code># set type of element
raw = raw.astype(float)
raw<jupyter_output><empty_output><jupyter_text>1.4 Create New DataframeNhư đã nói ở trên, sau bước đầu lựa chọn các feature có khả năng dự đoán năng lực của một sinh viên để dự đoán điểm CK, chúng em sẽ tạo một DataFrame hoàn toàn mới chứa các feature trên dựa vào data wecode ban đầu.<jupyter_code>#@title
index = raw.index.tolist()
list_tries = raw['tries'].tolist()
list_solved = raw['solved'].tolist()
list_numProblemSumbited = raw['num_problemSubmitted'].values.tolist()

list_numProblemSumbited,list_solved
#Tổng pre_score của các submssion có is_final = 1
list_totalFinalScore = raw['total_FinalScore'].tolist()

# Tổng số problem đã solved (is_final = 1 && pre_score=10000) / Tổng số problem có submit = solved/submiited
solved_per_submitted = []
for i in range(len(index)):
  solved_per_submitted.append(list_solved[i] / list_numProblemSumbited[i])

#Tổng số problem đã solved (is_final = 1 && pre_score=10000) / Tổng số lần thử submit = solved/tries
solved_tries = []
for i in range(len(index)):
  solved_tries.append(list_solved[i] / list_tries[i])
# # probSubmited_totalSubmit = []
# # for i in range(len(index)):
# #   probSubmited_totalSubmit.append(list_numProblemSumbited[i] / 264606)
dict_newData = {'index': index,
                    'tries': list_tries,
                    'solved': list_solved,
                    'submited': list_numProblemSumbited,
                    'solved/tries': solved_tries,
                    'solved/submited': solved_per_submitted,
                    'finalScore': list_totalFinalScore
}

newDF = pd.DataFrame(dict_newData).set_index('index')
newDF<jupyter_output><empty_output><jupyter_text>Tạo thêm 2 feature mới để đánh giá khả năng giải quyết bài toán của sinh viên, cụ thể là:* solved/tries: số các problem được AC trên tổng số lần thử của một user_id.* solved/submitted: số các problem được AC trên tổng số các problem được submit<jupyter_code>score_CK = data_score[['id', 'CK']]
score_CK.set_index('id', inplace=True)
new_data = pd.concat([newDF, score_CK], axis=1)
new_data.head(10).T<jupyter_output><empty_output><jupyter_text>2. Pre-processing Data and Show the Correlation of the features  2.1 Handling Missing Values in Data Sau khi kết hợp với cột điểm CK theo user_id, chúng em nhận thấy dữ liệu bị thiếu NaN khá nhiều, nên thay vì loại bỏ các dữ liệu thiếu đó dẫn đến gây mất thông tin. Chúng em sẽ "lấp" các dữ liệu đó bằng phép nội suy tuyến tính và điền trung bình theo cột. (trừ cột CK, vì sẽ được đem đi predict)<jupyter_code>#find NaN values and replace it with 0
def count_missing_values(data):
  num_of_miss_data = data.isnull().sum()
  missing_data = pd.concat([num_of_miss_data], axis=1, keys = ['Number of missing value'])
  return missing_data
count_missing_values(new_data)
#fill missing value of column 'tries'
new_data['tries'] = new_data['tries'].interpolate(method = 'pad', limit = 3)
new_data['tries'] = new_data['tries'].fillna(int(np.mean(new_data['tries'])))
#fill missing value of column 'solved'
new_data['solved'] = new_data['solved'].interpolate(method = 'pad', limit = 3)
new_data['solved'] = new_data['solved'].fillna(int(np.mean(new_data['solved'])))
#fill missing value of column 'summited'
new_data['submited'] = new_data['submited'].interpolate(method = 'pad', limit = 3)
new_data['submited'] = new_data['submited'].fillna(int(np.mean(new_data['submited'])))
new_data['solved/tries'] = new_data['solved'] / new_data['tries'] 
new_data['solved/submited'] = new_data['solved'] / new_data['submited'] 
new_data['finalScore'] = new_data['finalScore'].interpolate(method = 'pad', limit = 3)
new_data['finalScore'] = new_data['finalScore'].fillna(int(np.mean(new_data['finalScore'])))<jupyter_output><empty_output><jupyter_text>* Chia data frame vừa mới tạp thành hai tập **data_to_train** (các user_id đã có điểm CK) và **data_to_predict** (các user_id chưa có điểm CK và cần phải predict). * Loại bỏ các hàng sau khi xử lí dữ liệu thiếu không khớp với thông tin thực tế như hai chỉ số **solved/tries > 1** và **solved/submitted** > 1.<jupyter_code>data_to_predict = new_data[new_data.isna().any(axis=1)]
data_to_predict = data_to_predict[data_to_predict['solved/tries'] <= 1]
data_to_predict = data_to_predict[data_to_predict['solved/submited'] <= 1]
data_to_predict
#lưu id của các user cần predict điểm ck, sẽ sử dụng sau.
id_predict = data_to_predict.index.to_numpy()
data_to_train = new_data.dropna()
data_to_train = data_to_train[data_to_train['solved/tries'] <= 1]
data_to_train = data_to_train[data_to_train['solved/submited'] <= 1]
data_to_train.describe()<jupyter_output><empty_output><jupyter_text>2.2 Show the Correlation of  FeaturesSau các bước tiền xử lý dữ liệu cơ bản như trên, chúng em sẽ tiến hành lọc các feature một lần nữa bằng cách **trực quan hóa mối quan hệ giữa chúng đối với điểm CK** (bằng *Scatter Plot*)  và thể hiện sự tương quan giữa các feature (bằng *Correlation Matrix*)<jupyter_code>fig= plt.figure(figsize = (40,30))
gs1 = fig.add_gridspec(3,3)
gs1.update(wspace=0.4, hspace=0.4)

axs0 = fig.add_subplot(gs[0,0])
axs1 = fig.add_subplot(gs[0,1])
axs2 = fig.add_subplot(gs[1,0])
axs3 = fig.add_subplot(gs[1,1])
axs4 = fig.add_subplot(gs[2,0])
axs5 = fig.add_subplot(gs[2,1])
axes=[axs0,axs1,axs2,axs3,axs4, axs5]
background_color = '#f6f5f7'

for i in axes:
    i.set_facecolor(background_color)
fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs0, x = data_to_train['solved'], y = data_to_train['CK'].sort_values() )
axs0.set_title('Solved Assignments and Grade Final')

fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs1, x = data_to_train['solved/tries'], y = data_to_train['CK'].sort_values())
axs1.set_title('Solved/Tries Assignments and Grade Final')

fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs2,x = data_to_train['submited'], y = data_to_train['CK'].sort_values())
axs2.set_title('Submitted Assignments and Grade Final')

fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs3,x = data_to_train['solved/submited'], y = data_to_train['CK'].sort_values())
axs3.set_title('Solved/Submitted Assignments and Grade Final')

fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs4,x = data_to_train['finalScore'], y = data_to_train['CK'].sort_values())
axs4.set_title('finalScore and Grade Final')

fig.patch.set_facecolor(background_color) 
sns.scatterplot(ax = axs5,x = data_to_train['tries'], y = data_to_train['CK'].sort_values())
axs5.set_title('Tries and Grade Final')

plt.show()
data_to_cor = data_to_train.iloc[:,data_to_train.columns!='CK']
plt.figure(figsize=(12,10))
cor = data_to_cor.corr()
sns.heatmap(cor, annot=True, cmap=plt.cm.Blues)
plt.show()<jupyter_output><empty_output><jupyter_text>**Nhận xét**:+ Các features như **solved/tries**, **solved/submitted** có scatter plot trải đều, không theo quy luật, nhưng chúng em đã thử và khi bỏ hai cột feature trên, model dự đoán kém chính xác hơn so với lúc giữ hai cột feature.+ Các features như **tries, solved, submitted, finalScore** có scatter plot thể hiện được mối quan hệ giữa chúng với điểm CK khá tương đồng nhau, số lần **tries, solved, submitted** và **finalScore** ***càng cao*** thì điểm CK của user_id ***càng cao***+ Correlation giữa các feature trong bộ data frame cho thấy có 4 feature có mức độ tương quan với nhau tương đối cao **tries, solved, submitted, finalScore**, theo lý thuyết, chúng em sẽ bỏ 2 và giữ 2.=> Sau rất nhiều lần thử và dựa vào các phân tích trên, chúng em sẽ loại bỏ hai features là ***tries và solved***<jupyter_code>data_to_train = data_to_train.drop(['tries','solved'], axis = 1)
data_to_predict = data_to_predict.drop(['tries','solved'], axis = 1)

data_to_train.describe()<jupyter_output><empty_output><jupyter_text>* Như đã nói ở trên, điểm CK của các user_id trong khoảng điểm từ 9 - 10 rất ít nên có thể model sẽ không nắm bắt được tốt data khi user_id có số điểm như trên. Nên chúng em tiến hàng tăng dữ liệu liên quan tới khoảng điểm ít xuất hiện nhất của user_id bằng phương pháp OverSampling và ở đây chúng em sử dụng hàm SMOTE.* Cre tham khảo: [SMOTE](https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.SMOTE.html)<jupyter_code>def Oversampling(mode="SMOTE"):
  if mode == 'SMOTE':
    oversample = SMOTE(sampling_strategy='minority', k_neighbors=1)
    X, y = oversample.fit_sample(data_to_train.loc[:,data_to_train.columns!='CK'], data_to_train['CK'])
  elif mode == 'Borderline':
    oversample = BorderlineSMOTE()
    X, y = oversample.fit_sample(data_to_train.loc[:,data_to_train.columns!='CK'], data_to_train['CK'])
  elif mode == 'SVMSMOTE':
    oversample = SVMSMOTE()
    X, y = oversample.fit_sample(data_to_train.loc[:,data_to_train.columns!='CK'], data_to_train['CK'])
  elif mode == 'ADASYN':
    oversample = ADASYN()
    X, y = oversample.fit_sample(data_to_train.loc[:,data_to_train.columns!='CK'], data_to_train['CK'])

  return X, y
X, y = Oversampling('SMOTE')
print("Shape of X: {}".format(X.shape))
print("Shape of y: {}".format(y.shape))<jupyter_output>Shape of X: (1022, 4)
Shape of y: (1022,)<jupyter_text>* Dữ liệu được tạp thêm nên từ shape của tập dữ liệu X ban đầu *(920, 4)*, chúng em được một tập dữ liệu X mới có kích thước *(1022, 4)*.<jupyter_code>data_to_train.to_csv('/content/data_train.csv')
data_to_predict.to_csv('/content/data_test.csv')
# X = data_to_train.iloc[:,data_to_train.columns!='CK']
# y = data_to_train.iloc[:,-1]
# # X = np.array(data_to_train['finalScore']).reshape(-1,1)
# # y = data_to_train['CK']
# X<jupyter_output><empty_output><jupyter_text>* Bước tiếp theo chúng em chia dữ liệu từ tập X đã được xử lý ở trên thành hai bộ dữ liệu để train và để test theo tỷ lệ 80 - 20.* Sau đó chúng em scale hai tập dữ liệu trên bằng hàm StanderScaler() của sklearn* Để model nắm bắt train dữ liệu tốt hơn nữa, em sử dụng PolynomialFeatures để làm tăng feature cho bộ data từ feature ban đầu bằng phương pháp số mũ.* Cre tham khảo : [PolynomialFeatures](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html)<jupyter_code>x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.1, random_state = 0)
x_train
def normalize_train_test(X_train, X_test, raw_X, mode="StandardScaler"):
  if mode == "StandardScaler":
    scaler = StandardScaler()
  elif mode == "MinMaxScaler":
    scaler = MinMaxScaler()
  elif mode == "RobustScaler":
    scaler = RobustScaler()

  scaler = scaler.fit(X_train)
  
  X_train_std = scaler.transform(X_train)
  X_test_std = scaler.transform(X_test)
  raw_X_std = scaler.transform(raw_X)

  return scaler, X_train_std, X_test_std, raw_X_std
scaler, X_train_std, X_test_std, X_std = normalize_train_test(x_train, x_test, X, mode="StandardScaler")
poly = PolynomialFeatures(2)
x_train_poly = poly.fit_transform(X_train_std)
x_test_poly = poly.transform(X_test_std)<jupyter_output><empty_output><jupyter_text>3 Building Model to Predict and Testing* Sử dụng Ridge Regression để tạo model từ các tập dữ liệu đã qua các bước tiền xử lý trên.* Predict điểm CK cho các user_id chưa có điểm CK bằng model vừa train.  Bulding Model* Tìm tham số thích hợp nhất cho model bằng cách dùng hàm GridSearchCV của sklearn.<jupyter_code>from sklearn.model_selection import GridSearchCV

alpha_values = {'alpha':[0.001, 0.01,0.02,0.03,0.04, 0.05, 0.06,0.07, 0.08, 0.1]}

ridge= GridSearchCV(Ridge(), alpha_values, scoring='neg_mean_squared_error', cv=10 )

print('The best value of alpha is:',ridge.fit(x_train_poly,y_train).best_params_)

print('The best score for the best Lasso estimator is:',ridge.fit(x_train_poly,y_train).best_score_)
def train_model(X_train, y_train, mode = "Ridge"):
  if mode == "LinearRegression":
    model = LinearRegression()
  elif mode == "Ridge":
    model = Ridge()
  elif mode == "Lasso":
    model = Lasso()

  model.fit(X_train, y_train)

  return model

def predict_model(model, X_test):
  y_logit = model.predict(X_test)

  return y_logit
model  = Ridge(alpha = 0.1).fit(x_train_poly, y_train)
prediction = predict_model(model, x_test_poly)
prediction = prediction*2.0
prediction = prediction.astype(int)
prediction = np.round_(prediction/2, decimals=1, out=None)
prediction
# print('Model score on x_test', lr_model.score(x_test, y_test))
print('MSE: ', mean_squared_error(prediction, y_test))
print('R^2: ', model.score(x_test_poly, y_test) )
x_predict = data_to_predict.iloc[:,data_to_predict.columns!='CK']
# x_predict = x_predict.drop(['tries','solved/tries', 'solved/submited'], axis = 1)
x_std = scaler.transform(x_predict)
x_predict_poly = poly.fit_transform(x_std)
#submit prediction
y_predict = model.predict(x_predict_poly)
y_predict = y_predict*2.0
y_predict = y_predict.astype(int)
y_predict = np.round(y_predict/2, decimals=1, out=None)
y_predict
result = {
    "id": id_predict,
    "CK" :y_predict
}
result_submit = pd.DataFrame(result)
result_submit
#tạo file submit predict điểm những bạn chưa có điểm CK để thầy test
result_submit.to_csv('/content/submit_predict.csv')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12817964125965753, 'fraction_numerical': 0.021280440970496542, 'mean_word_length': 5.899625935162095, 'pattern_counts': {'":': 7, '<': 67, '<?xml version=': 0, '>': 70, 'https://': 8, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '397163', 'license': 'MIT', 'n_tokens_mistral': 9598, 'n_tokens_neox': 9283, 'n_words': 1995, 'path': 'COLAB_ASSIGNMENTS/COLAB_ASSIGNMENT_17_05/PREDICT_FINAL_SCORE_OF_IT001.ipynb', 'repo_name': '19522450/CS114.L21', 'size': '22164'}