<jupyter_start><jupyter_text>ابتدا باید کتابخانه های زیر را وارد کنیم:            numpy: برای کار با ماتریس ها        matplotlib: برای رسم نمودار        PCA: برای کاهش بعد        OpenCV: برای کار با عکس        special_ortho_group: برای تولید پایه اورتونرمال     تذکر: اگر کتابخانه cv2 اجرا نشد باید آن را نصب کنید. در command prompt دستور زیر را اجرا کنید. pip install opencv-python<jupyter_code>!pip install opencv-python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
import cv2
from scipy.stats import special_ortho_group as sog<jupyter_output><empty_output><jupyter_text>پروژه ۲: استفاده از کاهش بعد قسمت ۱.۱: تولید دیتا با استفاده از پایه اورتونرمال        عملیات زیر را انجام دهید:            ابتدا با استفاده از تابع np.zeros آلفا وکتور هایی با ابعاد dim و  N بسازید.        سعی کنید متغیر آلفا وکتور را طوری پر کنید که به ازای هر اندیس از بعد صفر آن، آرایه ای از توزیع نرمال با میانگین ۰ و انحراف معیار i+1 قرار گیرد.         بردار پایه V را با استفاده از تابع special_ortho_group.rvs(dim) بسازید.         مشخص کنید که در ده مولفه اول چند درصد دیتا برای هر کدام از ماتریس ها حفظ شده اند.          حال بردار زیر را تولید کنید و در alpha_v قرار دهید.         $$\alpha_1 V_1 + \alpha_2 V_2 + ... + \alpha_d V_d $$<jupyter_code>dim = 20
N = 1000

alpha_vectors = np.zeros((N, dim))

for i in range(N):
    alpha_vectors[i] = np.random.normal(0, i + 1, dim)

V = sog.rvs(dim)
alpha_v = np.matmul(alpha_vectors, V)
print(alpha_v)<jupyter_output>[[ 1.85796782e-01  5.95693503e-01 -1.06141413e+00 ...  1.25360933e+00
  -1.49196549e+00 -1.71645212e+00]
 [-5.52355256e-01 -2.32208128e-01 -1.45257747e+00 ... -5.75353815e-01
   5.32574186e-01 -1.13204072e+00]
 [ 1.62991497e+00  3.05093383e-01  1.85496227e+00 ... -2.02565163e+00
   3.66097985e+00  3.27154903e+00]
 ...
 [ 1.37340414e+03  1.19011377e+02 -1.16850578e+02 ...  1.26333703e+03
  -6.42699005e+02 -1.42814042e+03]
 [ 6.25504714e+01 -1.17225432e+03  2.19318481e+03 ... -6.21643322e+02
   6.56490839e+02 -1.19807228e+03]
 [-3.01445100e+02  5.06836655e+02 -1.09693110e+03 ...  7.73835725e+02
  -1.90212911e+03  6.61624113e+02]]<jupyter_text>قسمت ۱.۲:استفاده از PCA برای کاهش بعد        عملیات زیر را انجام دهید:            ابتدا یک شیی از PCA بسازید.        با استفاده از تابع fit موجود در شیی PCA عملیات pca را روی دیتا alpha_v انجام دهید.         با استفاده از تابع components_ موجود در شیی pca بردار های تکین را مشاهده کنید.         با استفاده از تابع explained_variance_ موجود در شیی pca مقدار های تکین را مشاهده کنید.<jupyter_code>pca = PCA()
pca.fit(alpha_v)
print(pca.components_)
print(pca.explained_variance_)<jupyter_output>[[ 3.34017742e-02 -1.18904961e-01 -4.25147294e-01  1.26947115e-01
   3.13449083e-01  2.54046525e-01  2.71726916e-01  1.80475336e-01
  -1.14252489e-01 -5.92359744e-02 -7.92421226e-02 -3.44459207e-01
   2.23677760e-01  4.90444010e-01 -1.12590124e-01  1.54180027e-01
  -5.84606532e-03  1.51139626e-01 -6.85230914e-02  1.50337823e-01]
 [-2.79972536e-01 -3.81875071e-04 -3.04331575e-01  3.97839316e-03
   6.49960142e-02  2.92714369e-02 -3.76792291e-01 -3.10187582e-02
  -2.83348780e-01 -1.72045979e-01  4.50357740e-01  1.19864404e-01
  -2.44852022e-01  2.43681415e-02 -4.27746871e-01 -2.69710242e-01
   1.16043399e-01  1.08055343e-01 -9.89675561e-02  5.19226613e-02]
 [ 5.66013430e-02  1.62255138e-01  1.89629385e-01 -7.90057936e-02
  -4.49016462e-01 -2.72328881e-03 -2.47581955e-01 -2.08425381e-01
   2.48299359e-01 -7.02058223e-02 -1.62835979e-01 -2.72148420e-01
  -2.34592829e-01  4.40363626e-01 -1.12763612e-01  4.19896907e-03
  -7.33795257e-03  3.30866712e-01 -2.58390114e-02  2.87861015e-01]
 [ 1.16[...]<jupyter_text>قسمت ۱.۳: کاهش بعد به ۳ بعد            ابتدا یک شیی از PCA با ورودی n_components=3 بسازید.        با استفاده از تابع fit موجود در شیی PCA عملیات pca را روی دیتا alpha_v انجام دهید.         تابع explained_variance_ratio_ موجود در شیی pca درصد حفظ دیتا به ازای هر کدام از بعد ها را می دهد.    با کاهش بعد به ۳، چند درصد از اطلاعات حفظ می شود؟<jupyter_code>pca = PCA(n_components = 3)
pca.fit(alpha_v)
print(str(100 * np.sum(pca.explained_variance_ratio_)) + " percent of data is preserved in 3 dimensions!")<jupyter_output>19.544901432955598 percent of data is preserved in 3 dimensions!<jupyter_text>برای حفظ ۹۰ درصد از اطلاعات به چند بعد نیاز داریم؟<jupyter_code>min_dim = 0
for i in range(1, dim):
    pca = PCA(n_components = i)
    pca.fit(alpha_v)
    if (np.sum(pca.explained_variance_ratio_) >= 0.9):
        min_dim = i
        break
print("Almost " + str(100 * np.sum(pca.explained_variance_ratio_)) + " percent of data is preserved in at least " + str(min_dim) + " dimensions!")<jupyter_output>Almost 93.01006062812166 percent of data is preserved in at least 18 dimensions!<jupyter_text>قسمت ۲.۱: خواندن فایل تصویرابتدا فایل تصویری رنگی باکیفیتی را از گوگل دانلود کنید.با استفاده از تابع imread موجود در کتابخانه OpenCV عکس مربوطه را فراخوانی کنید:<jupyter_code>image1 = cv2.imread("mona.jpg")<jupyter_output><empty_output><jupyter_text>عکس خوانده شده را به فرمت RGB در می آوریم:<jupyter_code>image = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)<jupyter_output><empty_output><jupyter_text>همانطور که می بینید عکس خوانده شده به ازای هر پیکسل ۳ عدد دارد: بنابراین برای هر عکس رنگی x*y یک آرایه x*y*3 خواهیم داشت.<jupyter_code>dim = image.shape
print('Image shape =', dim)<jupyter_output>Image shape = (720, 483, 3)<jupyter_text>قسمت ۲.۲: نمایش تصویربا استفاده از تابع imshow موجود در matplotlib تصویر خوانده شده را نمایش دهید:<jupyter_code>plt.imshow(image)
plt.show()<jupyter_output><empty_output><jupyter_text>قسمت ۲.۳: آماده سازی تصویر برای کاهش بعدسه ماتریس رنگ را در ماتریس های R,G,B ذخیره کنید:<jupyter_code>R = image[:, :, 0]
G = image[:, :, 1]
B = image[:, :, 2]
print(R.shape)
print(G.shape)
print(B.shape)<jupyter_output>(720, 483)
(720, 483)
(720, 483)<jupyter_text>قسمت ۲.۴:استفاده از PCA برای کاهش بعد    با استفاده از کلاس PCA در کتابخانه sklearn کاهش بعد را انجام میدهیم.    عملیات زیر را انجام دهید:    راهنمایی            برای هر یک از ماتریس های R,G,B یک شی PCA ایجاد کنید. تعداد مولفه ها را ۱۰ قرار دهید.        با استفاده از تابع fit موجود در pca الگوریتم را روی ماتریس ها فیت کنید.         با استفاده از دستور _explained_variance_ratio میتوانید ببینید هرکدام از مولفه ها چند درصد دیتای ماتریس را دارند.          مشخص کنید که در ده مولفه اول چند درصد دیتا برای هر کدام از ماتریس ها حفظ شده اند.          با استفاده از دستور bar مقادیر _explained_variance_ratio را رسم کنید<jupyter_code>k = 10
rpca = PCA(n_components = k)
gpca = PCA(n_components = k)
bpca = PCA(n_components = k)

rpca.fit(R)
gpca.fit(G)
bpca.fit(B)

print("First " + str(k) + " components of Red Matrix have " + str(100 * np.sum(rpca.explained_variance_ratio_)) + " percent of data.")
print("First " + str(k) + " components of Green Matrix have " + str(100 * np.sum(gpca.explained_variance_ratio_)) + " percent of data.")
print("First " + str(k) + " components of Blue Matrix have " + str(100 * np.sum(bpca.explained_variance_ratio_)) + " percent of data.")
plt.bar([i for i in range(k)], rpca.explained_variance_ratio_, color ='red', width = 0.4)
plt.xlabel("Red Components")
plt.ylabel("Variance %")
plt.show()

plt.bar([i for i in range(k)], gpca.explained_variance_ratio_, color ='green', width = 0.4)
plt.xlabel("Green Components")
plt.ylabel("Variance %")
plt.show()
plt.bar([i for i in range(k)], bpca.explained_variance_ratio_, color ='blue', width = 0.4)
plt.xlabel("Blue Components")
plt.ylabel("Variance %")
plt.show()<jupyter_output><empty_output><jupyter_text>عملیات زیر را انجام دهید:            با استفاده از تابع transform موجود در pca دیتا با بعد کمتر را تولید کنید         با استفاده از تابع inverse_transform دیتا را به بعد اولیه برگردانید<jupyter_code>Transform_R = rpca.transform(R)
Transform_B = gpca.transform(G)
Transform_G = bpca.transform(B)
Reduced_R = rpca.inverse_transform(Transform_R)
Reduced_G = gpca.inverse_transform(Transform_G)
Reduced_B = bpca.inverse_transform(Transform_B)

print('Transform Matrix Shape = ', Transform_R.shape)
print('Inverse Transform Matrix Shape = ', Reduced_R.shape)<jupyter_output>Transform Matrix Shape =  (720, 10)
Inverse Transform Matrix Shape =  (720, 483)<jupyter_text>با استفاده از دستور concatenate سه ماتریس ً Reduced_R,Reduced_G,Reduced_B را کنار هم قرار دهید تا یک آرایه x*y*3 ایجاد شود. x , y همان ابعاد تصویر اولیه (image) هستند با استفاده از دستور astype ماتریس بدست آمده را به عدد صحیح تبدیل کنید.عکس بدست آمده را با imshow نمایش دهید.<jupyter_code>Reduced_R = Reduced_R.reshape((dim[0], dim[1], 1))
Reduced_G = Reduced_G.reshape((dim[0], dim[1], 1))
Reduced_B = Reduced_B.reshape((dim[0], dim[1], 1))

reduced_image = np.dstack((Reduced_R, Reduced_G, Reduced_B))
final_image = reduced_image.astype(int)
print('final_image shape = ', final_image.shape)
plt.imshow(final_image)
plt.show()<jupyter_output>Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).<jupyter_text>قسمت ۲.۵:استفاده از PCA برای کاهش بعد و حفظ ۹۹ درصد داده ها کل قسمت ۲.۴ را مجددا اجرا کنید. این بار تعداد مولفه ها را عددی قرار دهید که در هر سه ماتریس R,G,B حداقل ۹۹ درصد داده ها حفظ شود.<jupyter_code>k = 188
rpca = PCA(n_components = k)
gpca = PCA(n_components = k)
bpca = PCA(n_components = k)

rpca.fit(R)
gpca.fit(G)
bpca.fit(B)
Transform_R = rpca.transform(R)
Transform_B = gpca.transform(G)
Transform_G = bpca.transform(B)
Reduced_R = rpca.inverse_transform(Transform_R)
Reduced_G = gpca.inverse_transform(Transform_G)
Reduced_B = bpca.inverse_transform(Transform_B)

print('Transform Matrix Shape = ', Transform_R.shape)
print('Inverse Transform Matrix Shape = ', Reduced_R.shape)
Reduced_R = Reduced_R.reshape((dim[0], dim[1], 1))
Reduced_G = Reduced_G.reshape((dim[0], dim[1], 1))
Reduced_B = Reduced_B.reshape((dim[0], dim[1], 1))

reduced_image = np.dstack((Reduced_R, Reduced_G, Reduced_B))
final_image = reduced_image.astype(int)
print('final_image shape = ', final_image.shape)
plt.imshow(final_image)
plt.show()
print(np.sum(rpca.explained_variance_ratio_))<jupyter_output>Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
{'fraction_non_alphanumeric': 0.10975248989251553, 'fraction_numerical': 0.12336061532393255, 'mean_word_length': 4.086258776328987, 'pattern_counts': {'":': 0, '<': 48, '<?xml version=': 0, '>': 49, 'https://': 0, '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': '14', 'dir': 'jupyter-structured-clean-dedup', 'id': '667872', 'license': 'MIT', 'n_tokens_mistral': 6540, 'n_tokens_neox': 5216, 'n_words': 1089, 'path': 'mini-project 2/CSPRJ2_9816603_abrehforoush.ipynb', 'repo_name': 'Alireza-Abrehforoush/Mathematical-Foundations-of-Data-Science', 'size': '10141'}