<jupyter_start><jupyter_text>Bài 1: Numpy và Linear RegressionTrong bài thực hành này, chúng ta sẽ - làm quen với numpy, một thư viện hỗ trợ tính toán trên ma trận và tensor hiệu quả;- giải linear regression bằng exact solution  1. Numpy Lớp np.array<jupyter_code>import numpy as np                 ## thêm thư viện với tên tắt là np

an_array = np.array([3, 33, 333])  #Tạo một mảng 1 chiều

print(type(an_array))              #In lớp của object vừa tạo
print(an_array.shape)              #In kích thước của mảng
print(an_array[0], an_array[1], an_array[2])    # Truy suất từng phần tử của mảng bằng index
an_array[0] =888            # ta có thể thay đổi giá trị của một phần tử trong mảng bằng lệnh truy suất và gán

print(an_array)
another = np.array([[11,12,13],[21,22,23]])   # tạo một mảng 2 chiều (ma trận)

print(another)  # in ma trận

print("Kích thước của ma trậng 2 dòng, 3 cột: ", another.shape)  # số hàng x số cột            

print("Truy suất các phần tử tại [0,0], [0,1], và [1,0] của ma trận: ", another[0, 0], ", ",another[0, 1],", ", another[1, 0])<jupyter_output>[[11 12 13]
 [21 22 23]]
Kích thước của ma trậng 2 dòng, 3 cột:  (2, 3)
Truy suất các phần tử tại [0,0], [0,1], và [1,0] của ma trận:  11 ,  12 ,  21<jupyter_text>Các phép toán<jupyter_code>x = np.array([[111,112],[121,122]], dtype=np.int)                  ## tạo một ma trận với từng phẩn từ kiểu int
y = np.array([[211.1,212.1],[221.1,222.1]], dtype=np.float64)      ## tạo một ma trận với từng phẩn từ kiểu float64

print(x)
print()
print(y)
# cộng ma trận
print(x + y)        
# trừ
print(x - y)
# nhân từng phần tử (element-wise product)
print(x * y)
# chia từng phần tử
print(x / y)
# nhân ma trận
print(np.matmul(x, y))
# nhân cho một số thực
print(0.01*x)
# tính ma trận nghịch đảo
print(np.linalg.inv(x))
# chuyển vị
print(x.T)<jupyter_output>[[111 121]
 [112 122]]<jupyter_text>Các hàm khác<jupyter_code># reshape 2x2 thành 4x1
print(x.reshape(4,1))
#tạo một ma trận toàn giá trị 1 có kích thước 3x4
print(np.ones((3,4)))
# nối 2 ma trận bằng cách nối cột với nhau
np.concatenate([x,y], axis=1)
# nối 2 ma trận bằng cách nối hàng với nhau
np.concatenate([x,y], axis=0)<jupyter_output><empty_output><jupyter_text>2. Linear Regression<jupyter_code>import pandas as pd
df = pd.read_csv("House_Price.csv")        ## load file csv vào pd.DataFrame
df.head()                 ## xem thử DataFrame
## vẽ hình
import matplotlib.pyplot as plt
plt.scatter(df["Size in feet squared"], df["Price in thousand dollar"])
plt.xlabel("Size in feet squared")
plt.ylabel("Price in thousand dollar")<jupyter_output><empty_output><jupyter_text>Bây giờ chúng ta muốn làm một bài toán dựa vào kích thước của ngôi nhà, đoán giá tiền- $X$ = diện tích ngôi nhà- $y$ = giá tiền (chưa biết, muốn dự đoán)Ta giả thiết $\hat{y} = aX + b$  với $a$ và $b$ là số thựcTa tìm $a$ và $b$ sao cho trung bình bình phương sai số nhỏ nhất khi đoán, tức là tìm $a$ và $b$ sao cho$$ \frac{1}{n} \sum (y-\hat{y})^2 = \frac{1}{n} \sum (y - aX - b)^2 $$đạt giá trị nhỏ nhất, với $n$ là số mẫu.Với $X$, $y$ là các ma trận với mỗi hàng là một sample, $X$ là data và $y$ là target.Gọi $Z$ là mận trận mở rộng của $X$ nhưng có thêm một cột toàn số 1.Khi đó nghiệm của bài toán Linear Regression là$$(Z^TZ)^{-1}Z^Ty.$$Tức là trong bài toán này, mỗi hàng của $X$ là diện tích của một căn nhà, tương ứng hàng của $y$ là giá của nhà đó. Cụ thể, bài toán được lập trình như sau<jupyter_code>X = df['Size in feet squared'].values    ## trích diện tích thành một mảng numpy
X = X.reshape(-1, 1)                     ## chuyển thành ma trận cột
y = df['Price in thousand dollar'].values   ## Trích giá tiền 
y = y.reshape(-1,1)

Z = np.concatenate([X, np.ones((100,1))], axis=-1)   ## thêm một cột vào sau X và gán vào Z
Z = Z.astype(np.float32)                                 ## chuyển sang float

## giá trị a và b tìm được
np.matmul(np.matmul(np.linalg.inv(np.matmul(Z.T,Z)), Z.T), y)
## vẽ hình
import matplotlib.pyplot as plt
plt.scatter(df["Size in feet squared"], df["Price in thousand dollar"])
plt.plot(np.arange(500, 3000), 0.23481099*np.arange(500, 3000) + 128.49492905)   ## vẽ solution tìm được
plt.xlabel("Size in feet squared")
plt.ylabel("Price in thousand dollar")<jupyter_output><empty_output><jupyter_text>Bài tậpCho dữ liệu gồm 100 hàng, gồm chiều rộng, chiều dài và giá của một ngôi nhà, hay xây dựng một mô hình dư đoán giá nhà dựa vào chiều dài và rộng.Hãy dùng mô hình học được: dự đoán xem căn nhà có thông số sau khả năng cao là giá bao nhiêu:- width = 5, length = 10- width = 20, length = 20- width = 10, length = 40 Nộp bài- Code và chạy kết quả lưu vào file notebook NMMH_TH1_MSSV.ipynb (notebook phải có kết quả chạy nếu ko xem như chưa làm)- Nén thành file NMMH_TH1_MSSV.rar (.zip) và nộp về: <EMAIL>- Deadline: 23g59 thứ 3 ngày 26/05/2020. Nộp trễ bị chia đôi số điểm.<jupyter_code># Import dependencies libraries
# Import numpy
import numpy as np 
# Import pandas
import pandas as pd
# Import matplotlib.pylot
import matplotlib.pyplot as plt
# Import seaborn
import seaborn as sns 
## Read input data
house_price = pd.read_csv('House_Price_2.csv')
house_price.head()
house_price.shape
house_price.describe()<jupyter_output><empty_output><jupyter_text>Data cleaning<jupyter_code># Checking Null values
house_price.isnull().sum()*100/house_price.shape[0]
# There are no NULL values in the dataset, hence it is clean.
for column in house_price.columns:
    print(column, len(house_price[str(column)].unique()))<jupyter_output>width 25
length 59
price 100<jupyter_text>Data visualization<jupyter_code>house_price.hist(figsize=(15, 10), bins=25, xlabelsize=10, ylabelsize=10)
fig, axs = plt.subplots(1, 2, sharey=True)
house_price.plot(kind='scatter', x='width', y='price', ax=axs[0], figsize=(16, 8))
house_price.plot(kind='scatter', x='length', y='price', ax=axs[1])<jupyter_output><empty_output><jupyter_text>Price data<jupyter_code>house_price.price.describe()
price_fig, price_axs = plt.subplots(ncols = 2, figsize=(15, 5))
sns.distplot(house_price['price'], kde=True, bins=20,  ax=price_axs[0])
sns.boxplot(y=house_price['price'], orient='v' ,ax=price_axs[1])<jupyter_output>/home/lenux/.local/lib/python3.8/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).
  warnings.warn(msg, FutureWarning)<jupyter_text>Width data<jupyter_code>house_price.width.describe()
width_fig, width_axs = plt.subplots(ncols = 2, figsize=(15, 5))
sns.distplot(house_price['width'], kde=True, bins=20,  ax=width_axs[0])
sns.boxplot(y=house_price['width'], orient='v' ,ax=width_axs[1])<jupyter_output>/home/lenux/.local/lib/python3.8/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).
  warnings.warn(msg, FutureWarning)<jupyter_text>Length data<jupyter_code>house_price.length.describe()
length_fig, length_axs = plt.subplots(ncols = 2, figsize=(15, 5))
sns.distplot(house_price['length'], kde=True, bins=20,  ax=length_axs[0])
sns.boxplot(y=house_price['length'], orient='v' ,ax=length_axs[1])
sns.pairplot(house_price)
plt.show()<jupyter_output><empty_output><jupyter_text>Splitting the Data into Training and Testing Sets<jupyter_code>from sklearn.model_selection import train_test_split

# We specify this so that the train and test data set always have the same rows, respectively
np.random.seed(0)
df_train, df_test = train_test_split(house_price, train_size = 0.7, test_size = 0.3, random_state = 100)
df_train.head()
df_train.describe()
x_train = df_train.drop(['price'], axis=1)
y_train = df_train.price
x_test = df_test.drop(['price'], axis=1)
y_test = df_test.price
x_train.shape, y_train.shape
x_test.shape, y_test.shape
X = x_train.values
X.shape               
y = y_train.values  
y = y.reshape(-1,1)
y.shape
Z = np.concatenate([X, np.ones((X.shape[0],1))], axis=-1)
Z = Z.astype(np.float32)                               
w = np.matmul(np.matmul(np.linalg.inv(np.matmul(Z.T,Z)), Z.T), y)
w
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, explained_variance_score, r2_score, accuracy_score
# Mô hình hồi quy tuyến tính
Lin_reg = LinearRegression(fit_intercept=True)
Lin_reg.fit(x_train, y_train)
# Hệ số của các đặc trưng, hệ số chặn trong mô hình regression của dữ liệu, điểm số trên tập test
print('Linear regression intercept = ', Lin_reg.intercept_) # hệ số bậc 0
print('Linear regression coefficient = ', Lin_reg.coef_) # hệ số bậc 1
print('Linear regression score on test data = ', Lin_reg.score(x_test, y_test)) #: phương sai
# Hệ số của các đặc trưng
for i in range(len(x_train.columns)):
    print(x_train.columns[i], ": ", Lin_reg.coef_[i])
# Test trên tập huấn luyện
y_train_pred = Lin_reg.predict(x_train)

rmse = np.sqrt(mean_squared_error(y_train,y_train_pred))
r2 = r2_score(y_train,y_train_pred)

print('RMSE: ', rmse)
print('R2: ', r2)
# Predict
y_pred = Lin_reg.predict(x_test)
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = (np.sqrt(mse))
mv = explained_variance_score(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

output = pd.DataFrame(y_test[0:10])
output['predicted price'] = y_pred[0:10]
output['difference'] = output['predicted price'] - output['price']
print(output, "\n")

print("Model testing performance:")
print("--------------------------")
print("Mean Absolute Error is", round(mae,1))
print('RMSE is {}'.format(rmse))
print('R2 score is {}'.format(r2))
print("Variance explained by model", round(mv*100,5), "%")
# plotting
plt.figure(figsize=(12,8))

plt.scatter(y_train_pred, y_train_pred - y_train,
          c = 'gray', marker = 'o', s = 35, alpha = 0.5,
          label = 'Train data')
plt.scatter(y_pred, y_pred - y_test,
          c = 'blue', marker = 'o', s = 35, alpha = 0.7,
          label = 'Test data')
plt.title('Scatter plot prediction on train and test data')
plt.xlabel('Predicted values')
plt.ylabel('Actual values')
plt.legend(loc = 'upper right')
plt.hlines(y = 0, xmin = 0, xmax=6000, lw = 2, color = 'red')
plt.grid()
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13433976686413146, 'fraction_numerical': 0.03210395566596599, 'mean_word_length': 4.511848341232228, 'pattern_counts': {'":': 1, '<': 45, '<?xml version=': 0, '>': 45, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '580227', 'license': 'MIT', 'n_tokens_mistral': 4801, 'n_tokens_neox': 4602, 'n_words': 1182, 'path': 'Lab01/Lab01.ipynb', 'repo_name': 'nhutnamhcmus/lab-machine-learning-solution', 'size': '10486'}