<jupyter_start><jupyter_text>Projekt IUM  Ogólne informacje Realizujący:* <NAME>* <NAME> <NAME>:* Baza użytkowników ("users.json")* Katalog produktów ("delivery.json")* Historia sesji ("sessions.json")* Dostawy produktów ("deliveries.json")<jupyter_code>import pandas as pd
import numpy as np
import itertools
import hashlib

# visualization
import matplotlib.pyplot as plt
import seaborn as sns

# sklearn
from sklearn import linear_model
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.metrics import mean_absolute_error
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

import tensorflow as tf<jupyter_output><empty_output><jupyter_text>Ustawienie ziarna<jupyter_code>np.random.seed(0)<jupyter_output><empty_output><jupyter_text>Wczytujemy przygotowane dane<jupyter_code>processed_data = pd.read_csv('processed_data.csv')
processed_data<jupyter_output><empty_output><jupyter_text>Uczenie  Wybranie danych nadających się do uczenia<jupyter_code>data_to_learning = processed_data.dropna(subset=['next_months_sum'])
data_to_learning<jupyter_output><empty_output><jupyter_text>Rozdzielenie danych na zbiór uczący i testowy<jupyter_code>msk = np.random.rand(len(data_to_learning)) < 0.8
train = data_to_learning[msk]
test = data_to_learning[~msk]
print(test)
train<jupyter_output>Unnamed: 0  user_id    city  year  month  total_web_events  \
38            68      104  Police  2020      9               4.0   
39            69      104  Police  2020      4              22.0   
58            99      106  Mielec  2021      1               0.0   
76           136      107  Police  2020     11               0.0   
78           138      107  Police  2020      7              29.0   
...          ...      ...     ...   ...    ...               ...   
2737        4697      297  Mielec  2020      5              33.0   
2741        4701      297  Mielec  2020      4              13.0   
2746        4707      298  Gdynia  2021      1               9.0   
2748        4717      298  Gdynia  2020      3              44.0   
2757        4727      298  Gdynia  2020      8              18.0   

      buying_events  num_dropped_monthly  sum_after_discount  next_months_sum  
38              0.0                  0.0               0.000          141.683  
39              3.0    [...]<jupyter_text>Uczenie modelu - model liniowy - jenda zmienna z wizualizacją  Przygotowanie wejścia/wyjścia<jupyter_code>inputs_train = train.dropna(subset=['next_months_sum'])
# x = inputs[['user_id', 'year', 'month', 'total_web_events','buying_events', 'num_dropped_monthly', 'sum_after_discount']].values
x = inputs_train[['sum_after_discount']].values
y = train.next_months_sum.values

inputs_tests = test.dropna(subset=['next_months_sum'])
x_test = inputs_tests[['sum_after_discount']].values
y_test = test.next_months_sum.values<jupyter_output><empty_output><jupyter_text>Trenowanie modelu<jupyter_code>slr_sv = LinearRegression()
slr_sv.fit(x, y)<jupyter_output><empty_output><jupyter_text>Wizualizacja<jupyter_code># wizualizacja
def lin_regplot(x, y, model):
    plt.scatter(x, y, c='steelblue', edgecolor='white', s=70)
    plt.plot(x, model.predict(x), color='black', lw=2)

lin_regplot(x, y, slr_sv)
plt.show()

print("błąd doapsowania do danych uczących:", mean_absolute_error(y, slr_sv.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, slr_sv.predict(x_test)))<jupyter_output><empty_output><jupyter_text>Uczenie modelu - model liniowy - wszystkie zmienne  Przygotowanie danych<jupyter_code>inputs_train = train.dropna(subset=['next_months_sum'])
columns = inputs_train.columns
columns = columns.drop('next_months_sum')
columns = columns.drop('city')
x = inputs_train[columns].values
y = train.next_months_sum.values

inputs_tests = test.dropna(subset=['next_months_sum'])
columns = inputs_train.columns # - ['next_months_sum', 'city']
columns = columns.drop('next_months_sum')
columns = columns.drop('city')
x_test = inputs_tests[columns].values
y_test = test.next_months_sum.values<jupyter_output><empty_output><jupyter_text>Trenowanie modelu<jupyter_code>slr = LinearRegression()
slr.fit(x, y)
#slr.predict(x_test)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, slr.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, slr.predict(x_test)))<jupyter_output>błąd doapsowania do danych uczących: 2236.25014625736
błąd dopasowania do danych testowych:  2072.1819912708143<jupyter_text>Uczenie modelu - model kwadratowy  Przygotowanie danych<jupyter_code>inputs_train = train.dropna(subset=['next_months_sum'])
columns = inputs_train.columns
columns = columns.drop('next_months_sum')
columns = columns.drop('city')
x = inputs_train[columns].values
y = train.next_months_sum.values

inputs_tests = test.dropna(subset=['next_months_sum'])
columns = inputs_train.columns # - ['next_months_sum', 'city']
columns = columns.drop('next_months_sum')
columns = columns.drop('city')
x_test = inputs_tests[columns].values
y_test = test.next_months_sum.values<jupyter_output><empty_output><jupyter_text>Przekształcenie cech do modelu kwadratowego<jupyter_code>quadratic = PolynomialFeatures(degree=2)
x_quad = quadratic.fit_transform(x)
x_test_quad = quadratic.fit_transform(x_test)<jupyter_output><empty_output><jupyter_text>Uczenie modelu<jupyter_code>pr = LinearRegression()
pr.fit(x_quad, y)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, pr.predict(x_quad)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, pr.predict(x_test_quad)))<jupyter_output>błąd doapsowania do danych uczących: 2032.0807426295266
błąd dopasowania do danych testowych:  2095.4887358580095<jupyter_text>Model sześcienny<jupyter_code>cubic = PolynomialFeatures(degree=3)
x_cub = cubic.fit_transform(x)
x_test_cub = cubic.fit_transform(x_test)
cr = LinearRegression()
cr.fit(x_cub, y)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, cr.predict(x_cub)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, cr.predict(x_test_cub)))<jupyter_output>błąd doapsowania do danych uczących: 1856.8680092757477
błąd dopasowania do danych testowych:  2217.368135044513<jupyter_text>Widać, że zwiększanie złożoności modelu wielomianowego nie jest dobrym kierunkiem  Drzewo decyzyjne  Badanie optymalnej głębokości<jupyter_code>mean_a_error_train = []
mean_a_error_test = []
for idx in range(1, 12):
    tree = DecisionTreeRegressor(max_depth=idx)
    tree.fit(x,y)
    mean_a_error_train.append(mean_absolute_error(y, tree.predict(x)))
    mean_a_error_test.append(mean_absolute_error(y_test, tree.predict(x_test)))
plt.scatter(range(1, 12), mean_a_error_test)
plt.scatter(range(1, 12), mean_a_error_train)
plt.show()
mean_a_error_train = []
mean_a_error_test = []
for idx in range(1, 30):
    tree = DecisionTreeRegressor(max_depth=4, min_samples_leaf=idx)
    tree.fit(x,y)
    mean_a_error_train.append(mean_absolute_error(y, tree.predict(x)))
    mean_a_error_test.append(mean_absolute_error(y_test, tree.predict(x_test)))
plt.scatter(range(1, 30), mean_a_error_test)
plt.scatter(range(1, 30), mean_a_error_train)
plt.show()<jupyter_output><empty_output><jupyter_text>Na pomarańczowo jest zaznaczone MAE zbioru trenującego, a na niebiesko zbioru testowego. Najlepszy wynik jest dla drzewa o głębokości 4<jupyter_code>tree = DecisionTreeRegressor(max_depth=4, min_samples_leaf=7)
tree.fit(x,y)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, tree.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, tree.predict(x_test)))<jupyter_output>błąd doapsowania do danych uczących: 1960.8265242317234
błąd dopasowania do danych testowych:  1850.6399359961913<jupyter_text>Las losowy<jupyter_code>forest = RandomForestRegressor(n_estimators=500,
                              criterion='mse',
                              random_state=1,
                              n_jobs=-1,
                              min_samples_leaf=2)
forest.fit(x,y)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, forest.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, forest.predict(x_test)))<jupyter_output>błąd doapsowania do danych uczących: 1127.0930305351342
błąd dopasowania do danych testowych:  1857.7723714863716<jupyter_text>Wzmacnianie gradientowe<jupyter_code>gbrt = GradientBoostingRegressor(max_depth=5, n_estimators=80)
gbrt.fit(x, y)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, gbrt.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, gbrt.predict(x_test)))<jupyter_output>błąd doapsowania do danych uczących: 1122.0399424401287
błąd dopasowania do danych testowych:  1910.2213868540764<jupyter_text>Sieć neuronowa  Zdefiniowanie modelu keras<jupyter_code>n_features = 8
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(20, input_dim=n_features, activation='relu', kernel_initializer='he_normal'))
model.add(tf.keras.layers.Dense(10, activation='relu', kernel_initializer='he_normal'))
model.add(tf.keras.layers.Dense(1, activation='linear'))<jupyter_output><empty_output><jupyter_text>Skompilowanie modelu<jupyter_code>model.compile(loss='mse', optimizer='adam')
model.fit(x, y, epochs=50, batch_size=32, verbose=2)
print("błąd doapsowania do danych uczących:", mean_absolute_error(y, model.predict(x)))
print("błąd dopasowania do danych testowych: ", mean_absolute_error(y_test, model.predict(x_test)))<jupyter_output>Epoch 1/50
23/23 - 0s - loss: 7525148.5000
Epoch 2/50
23/23 - 0s - loss: 7553048.5000
Epoch 3/50
23/23 - 0s - loss: 7475919.5000
Epoch 4/50
23/23 - 0s - loss: 7661119.0000
Epoch 5/50
23/23 - 0s - loss: 7637231.0000
Epoch 6/50
23/23 - 0s - loss: 7654941.0000
Epoch 7/50
23/23 - 0s - loss: 7657016.5000
Epoch 8/50
23/23 - 0s - loss: 7660393.0000
Epoch 9/50
23/23 - 0s - loss: 7514927.5000
Epoch 10/50
23/23 - 0s - loss: 7508771.5000
Epoch 11/50
23/23 - 0s - loss: 7521346.5000
Epoch 12/50
23/23 - 0s - loss: 7585417.0000
Epoch 13/50
23/23 - 0s - loss: 7848120.0000
Epoch 14/50
23/23 - 0s - loss: 7714915.5000
Epoch 15/50
23/23 - 0s - loss: 7568259.0000
Epoch 16/50
23/23 - 0s - loss: 7553737.5000
Epoch 17/50
23/23 - 0s - loss: 7549704.5000
Epoch 18/50
23/23 - 0s - loss: 7605648.0000
Epoch 19/50
23/23 - 0s - loss: 7721844.5000
Epoch 20/50
23/23 - 0s - loss: 7621056.5000
Epoch 21/50
23/23 - 0s - loss: 7530580.0000
Epoch 22/50
23/23 - 0s - loss: 7612533.5000
Epoch 23/50
23/23 - 0s - loss: 7597354.00[...]
{'fraction_non_alphanumeric': 0.10830763480048594, 'fraction_numerical': 0.08316979721521353, 'mean_word_length': 4.7168803418803416, 'pattern_counts': {'":': 0, '<': 77, '<?xml version=': 0, '>': 76, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '299731', 'license': 'MIT', 'n_tokens_mistral': 4755, 'n_tokens_neox': 4207, 'n_words': 753, 'path': 'learning.ipynb', 'repo_name': 'amasiukevich/IUM_shop', 'size': '10730'}