keras L1正则化不适用于线性回归

wsxa1bj1  于 2024-01-08  发布在  其他
关注(0)|答案(1)|浏览(98)

L1正则化不适用于线性回归，在下面的例子中，我创建了一个数据y = 2x1+ 5x2 + 3*x3 + 5
在数据集中，x4参数是存在的，但是为了计算样本数据中的输出，我们没有使用它，所以当我们应用L1正则化时，我们应该得到w4接近于零，但是它仍然不起作用。

  1. # In[1]:
  3. import pandas as pd
  4. import numpy as np
  5. import tensorflow as tf
  6. from matplotlib import pyplot as plt
  8. # In[2]:
  10. def plot_the_data(training_df, output):
  11.   plt.xlabel("feature")
  12.   plt.ylabel("label")
  13.   plt.ylim([output.min() - 1 , output.max() + 1])
  14.   print(training_df.columns)
  15.   for column in training_df.columns:
  16.     print(training_df[column].shape)
  17.     plt.xlabel(column)
  18.     plt.scatter(training_df[column], output)
  19.     plt.show()
  21. total_data = 10000
  22. output_label = 'output'
  23. normalize_data = True
  24. def createData(total_data):
  25.   my_label = np.zeros((total_data,))
  26.   my_feature = np.append(np.random.uniform(low=10, high=100, size=(total_data,)).reshape((total_data, 1)), # first col
  27.                        np.random.uniform(low=300, high=500, size=(total_data,)).reshape((total_data, 1)), axis=1)  # sec col
  28.   my_feature = np.append(my_feature , 
  29.                        np.random.uniform(low=600, high=800, size=(total_data,)).reshape((total_data, 1)), axis=1)  # third col
  30.   my_feature = np.append(my_feature , 
  31.                        np.random.uniform(low=900, high=1000, size=(total_data,)).reshape((total_data, 1)), axis=1)  # fourth col, unused
  33.   for i, row in enumerate(my_feature):
  34.     my_label[i] = ((2 +  np.random.uniform(0.0, 0.1) ) * row[0]) + ((5 + np.random.uniform(0.0, 0.1) )* row[1]) + ((3 + np.random.uniform(0.0, 0.1) )* row[2]) + (50 + np.random.randint(low=1, high=3))
  36.   training_df = pd.DataFrame({ 'x1' : my_feature[:,0], 'x2' : my_feature[:,1], 'x3' : my_feature[:,2], 'x4' : my_feature[:,3], 'output': my_label})
  37.   return training_df 
  39. training_df = createData(total_data)
  40. training_df = training_df.reindex(np.random.permutation(training_df.index))
  41. training_df[output_label] = training_df[output_label] / 1000
  42. print(training_df)
  43. plot_the_data(training_df, training_df[output_label])
  45. # In[3]:
  47. def normalize_the_data(training_df):
  48.   normalized_df = pd.DataFrame()
  49.   norm_list = {}
  50.   for column in training_df.columns:
  51.     print(f"Max, Min of {column} pre normalization: {np.max(training_df[column]):0.2f}, {np.min(training_df[column]):0.2f}")
  52.     norm_l = tf.keras.layers.Normalization(axis=-1)
  53.     norm_l.adapt(training_df[column])  # learns mean, variance
  54.     Xn = norm_l(training_df[column])
  55.     normalized_df[column] = Xn.numpy()[0]
  56.     norm_list[column] = norm_l
  57.     print(f"Max, Min of {column} post normalization: {np.max(normalized_df[column]):0.2f}, {np.min(normalized_df[column]):0.2f}")
  58.   return normalized_df, norm_list
  60. def normalize_the_test_data(training_df, norm_list):
  61.   normalized_df = pd.DataFrame()
  62.   for column in training_df.columns:
  63.     print(f"Max, Min of {column} pre normalization: {np.max(training_df[column]):0.2f}, {np.min(training_df[column]):0.2f}")
  64.     norm_l = norm_list[column]
  65.     norm_l.adapt(training_df[column])  # learns mean, variance
  66.     Xn = norm_l(training_df[column])
  67.     normalized_df[column] = Xn.numpy()[0]
  68.     print(f"Max, Min of {column} post normalization: {np.max(normalized_df[column]):0.2f}, {np.min(normalized_df[column]):0.2f}")
  69.   return normalized_df
  70.     
  71. if normalize_data == True:
  72.   print("Data Normalization enabled")
  73.   norm_l = tf.keras.layers.Normalization(axis=-1)
  74.   normalized_df, norm_l = normalize_the_data(training_df)
  75. else:
  76.   print("Data Normalization disabled")
  77.   normalized_df = training_df
  79. # In[4]:
  81. normalized_df = normalized_df.loc[:, normalized_df.columns != output_label]
  83. # In[5]:
  85. tf.random.set_seed(1)
  86. learning_rate=0.01
  87. my_learning_rate = learning_rate
  88. epochs=20
  89. batch_size=20
  90. validation_split = 0.2
  91. print(normalized_df.head())
  92. model = tf.keras.models.Sequential()
  93. model.add(tf.keras.layers.Dense(units=1, input_shape=(training_df.shape[1] - 1,), kernel_regularizer='l2'))
  95. model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=my_learning_rate),
  96.                 loss="mean_squared_error",
  97.                 metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.Accuracy()])    
  98. model.summary()
  99. weights_dict = {}
  100. weight_callback = tf.keras.callbacks.LambdaCallback(on_epoch_end=lambda epoch, logs: weights_dict.update({epoch: { "w" : model.get_weights()[0][0][0], "b" : model.get_weights()[1][0]}}))
  102. history = model.fit(x=normalized_df,
  103.                       y=training_df[output_label],
  104.                       # verbose='0',
  105.                       batch_size=batch_size,
  106.                       epochs=epochs,
  107.                       callbacks=weight_callback,
  108.                       validation_split=validation_split)
  110. # Gather the trained model's weight and bias.
  111. trained_weight = model.get_weights()[0]
  112. trained_bias = model.get_weights()[1]
  113. epochs = history.epoch  
  114. hist = pd.DataFrame(history.history)
  115. rmse = hist["root_mean_squared_error"]
  116. testrmse = hist["val_root_mean_squared_error"]  
  117. print("Defined build_model and train_model", trained_weight, trained_bias)
  119. # In[6]:
  121. predictions = model.predict(normalized_df)
  122. print(training_df.loc[:, training_df.columns == output_label])
  123. plot_the_data( training_df.loc[:, training_df.columns == output_label],  predictions.T)
  125. # In[7]:
  127. def plot_the_data_and_pred(training_df, output, pred):
  128.   plt.xlabel("feature")
  129.   plt.ylabel("label")
  130.   print(training_df.columns)
  131.   for column in training_df.columns:
  132.     plt.xlabel(column)
  133.     plt.scatter(training_df[column], output)
  134.     plt.scatter(training_df[column], pred)
  135.     plt.show()
  137. plot_the_data_and_pred(training_df, training_df[output_label], predictions)
  139. # In[8]:
  141. def plot_the_loss_curve(epochs, rmse, testrmse):
  142.   """Plot the loss curve, which shows loss vs. epoch."""
  143.   plt.figure()
  144.   plt.xlabel("Epoch")
  145.   plt.ylabel("Root Mean Squared Error")
  146.   plt.plot(epochs, rmse, label="Training Loss")
  147.   plt.plot(epochs, testrmse, label="Validation Loss")
  148.   # plt.plot(epochs, rmse, label="Loss")
  149.   plt.legend()
  150.   #y axis limit for the y axes
  151.   plt.ylim([rmse.min()*0.97, rmse.max() + 10])
  152.   plt.show()
  153.     
  154. plot_the_loss_curve(epochs, rmse, testrmse)
  156. # In[9]:
  158. output_label = 'output'
  159. total_test_data = 1000
  160. my_test_label = np.zeros((total_test_data,))
  162. def createTestData(total_data):
  163.   my_label = np.zeros((total_data,))
  164.   my_feature = np.append(np.random.uniform(low=50, high=60, size=(total_data,)).reshape((total_data, 1)), # first col
  165.                        np.random.uniform(low=350, high=400, size=(total_data,)).reshape((total_data, 1)), axis=1)  # sec col
  166.   my_feature = np.append(my_feature , 
  167.                        np.random.uniform(low=690, high=750, size=(total_data,)).reshape((total_data, 1)), axis=1)  # third col
  168.   my_feature = np.append(my_feature , 
  169.                        np.random.uniform(low=950, high=975, size=(total_data,)).reshape((total_data, 1)), axis=1)  # fourth col, unused
  171.   for i, row in enumerate(my_feature):
  172.     my_label[i] = ((2 +  np.random.uniform(0.0, 0.1) ) * row[0]) + ((5 + np.random.uniform(0.0, 0.1) )* row[1]) + ((3 + np.random.uniform(0.0, 0.1) )* row[2]) + (50 + np.random.randint(low=1, high=3))
  174.   training_df = pd.DataFrame({ 'x1' : my_feature[:,0], 'x2' : my_feature[:,1], 'x3' : my_feature[:,2], 'x4' : my_feature[:,3], 'output': my_label})
  175.   return training_df 
  177. test_df = createTestData(total_test_data)
  178. test_df[output_label] = test_df[output_label] / 1000
  179. print(test_df)
  180. # plot_the_data(test_df, test_df[output_label])
  182. if normalize_data == True:
  183.   print("Data Normalization enabled")
  184.   normalised_test_df = normalize_the_test_data(test_df, norm_l)
  185. else:
  186.   print("Data Normalization disabled")
  187.   normalised_test_df = test_df
  189. normalised_test_df = normalised_test_df.loc[:, normalised_test_df.columns != output_label]
  190. print(normalised_test_df)
  191. test_predictions = model.predict(normalised_test_df)
  192. plot_the_data( test_df.loc[:, test_df.columns != output_label], test_df[output_label])
  194. plot_the_data_and_pred(test_df.loc[:, test_df.columns != output_label], test_df[output_label], test_predictions)
  196. # In[10]:
  198. print("Defined build_model and train_model", trained_weight, trained_bias)
  200. # In[11]:
  202. results = model.evaluate(normalised_test_df, test_df[output_label], batch_size=batch_size)
  204. # In[12]:
  206. tf.random.set_seed(1)
  207. epochs = 20
  208. model = tf.keras.models.Sequential()
  209. model.add(tf.keras.layers.Dense(units=1, input_shape=(training_df.shape[1] - 1,), kernel_regularizer='l1'))
  211. model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=my_learning_rate),
  212.                 loss="mean_squared_error",
  213.               
  214.                 metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.Accuracy()])    
  215. model.summary()
  216. weights_dict = {}
  217. weight_callback = tf.keras.callbacks.LambdaCallback(on_epoch_end=lambda epoch, logs: weights_dict.update({epoch: { "w" : model.get_weights()[0][0][0], "b" : model.get_weights()[1][0]}}))
  219. history = model.fit(x=normalized_df,
  220.                       y=training_df[output_label],
  221.                       # verbose='0',
  222.                       batch_size=batch_size,
  223.                       epochs=epochs,
  224.                       callbacks=weight_callback,
  225.                       validation_split=validation_split)
  227. # Gather the trained model's weight and bias.
  228. trained_weight = model.get_weights()[0]
  229. trained_bias = model.get_weights()[1]
  230. epochs = history.epoch  
  231. hist = pd.DataFrame(history.history)
  232. rmse = hist["root_mean_squared_error"]
  233. testrmse = hist["val_root_mean_squared_error"]  
  234. print("Defined build_model and train_model", trained_weight, trained_bias)
  236. # In[13]:
  238. results = model.evaluate(normalised_test_df, test_df[output_label], batch_size=batch_size)
  240. # In[ ]:

字符串

keras

1条答案

按热度按时间
mctunoxg

mctunoxg1#

看起来你正在对训练数据进行归一化，但不清楚测试数据是否以同样的方式进行归一化。请确保这样做。
当应用L1正则化时，正则化项应该在模型编译过程中添加到损失函数中。尝试这样做：

  1. model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=my_learning_rate),loss=tf.keras.losses.MeanSquaredError() + tf.keras.regularizers.L1(0.01), metrics=[tf.keras.metrics.RootMeanSquaredError(), tf.keras.metrics.Accuracy()])
  2. model.summary()

字符串
如果你能分享一些玩具数据我就能复制这个了。

赞(0）分享  回复(0）举报  2024-01-08
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com