卷积神经网络做回归预测_卷积神经网络做回归预测

# -*- coding: utf-8 -*- import matplotlib.pyplot as plt import numpy as np from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression if __name__ == '__main__': # generate a random dataset np.random.seed(42) m = 100 X = 6 * np.random.rand(m, 1) - 3 y = 0.5 * X ** 2 + X + 2 + np.random.randn(m, 1) plt.plot(X, y, "b.") plt.xlabel("$x_1$", fontsize=18) plt.ylabel("$y$", rotation=0, fontsize=18) plt.axis([-3, 3, 0, 10]) plt.show() # use Scikit-Learn PolynomialFeature class to constructing parameter terms. # a,b,degree=2: [a, b, a^2, ab, b^2] # a,b,degree=3: [a, b, a^2, ab, b^2, a^3, a^2b, ab^2, b^3] # a,b,c,degree=3: [a, b, c, a^2, ab, ac, b^2, bc, c^2, a^3, a^2b, a^2c, ab^2, ac^2, abc, b^3, b^2c, bc^2, c^3] poly_features = PolynomialFeatures(degree=2, include_bias=False) # fit the dataset with Polynomial Regression Function, and X_poly is the fitting X result X_poly = poly_features.fit_transform(X) print "X: ", X print "X_poly: ", X_poly lin_reg = LinearRegression() lin_reg.fit(X_poly, y) print(lin_reg.intercept_, lin_reg.coef_) # draw the prediction curve X_new = np.linspace(-3, 3, 100).reshape(100, 1) # fit the X_new dataset with Polynomial Regression Function, and X_new_poly is the fitting X result X_new_poly = poly_features.transform(X_new) y_new = lin_reg.predict(X_new_poly) plt.plot(X, y, "b.") plt.plot(X_new, y_new, "r-", linewidth=2, label="Predictions") plt.xlabel("$x_1$", fontsize=18) plt.ylabel("$y$", rotation=0, fontsize=18) plt.legend(loc="upper left", fontsize=14) plt.axis([-3, 3, 0, 10]) plt.show()

https://blog.csdn.net/tsinghuahui/article/details/ https://www.jianshu.com/p/9185bc96bfa9 https://blog.csdn.net/_/article/details/

http://staff.ustc.edu.cn/~lgliu/Resources/DL/What_is_DeepLearning.html K. Hornik, et al. Multilayer feedforward networks are universal approximations. Neural Networks, 2: 359-366, 1989. G. Cybenko. Approximation by superpositions of a sigmoidal function. Math. Control Signals System, 2: 303-314, 1989. K. Hornik. Approximation capabilities of multilayer feedforward networks. Neural Networks, 4: 251-257, 1991.

https://cosx.org/2016/06/discussion-of-sparse-coding-in-deep-learning/

# -*- coding: utf-8 -*- import numpy as np import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression from sklearn import cross_validation if __name__ == '__main__': # 首先捏造一份好的数据，样本量为100，特征数为8，且满足方程: y = 5x_0 + 6x_1 + 7x_2 + 8x_3 + 9x_4 + 10x_5 + 11x_6 + 12x_7 + b coef0 = np.array([5, 6, 7, 8, 9, 10, 11, 12]) X1 = np.random.rand(100, 8) # 误差项是期望为0，标准差为1.5的正态分布随机变量。 y = np.dot(X1, coef0) + np.random.normal(0, 1.5, size=100) training = np.random.choice([True, False], p=[0.8, 0.2], size=100) lr1 = LinearRegression() lr1.fit(X1[training], y[training]) # 系数的均方误差MSE print "lr1 MSE: ", (((lr1.coef_ - coef0) ** 2).sum() / 8) # 测试集准确率（R2） print "lr1 R2:", (lr1.score(X1[~training], y[~training])) # 平均测试集准确率 print "lr1 MR2:", (cross_validation.cross_val_score(lr1, X1, y, cv=5).mean()) # 基于上面构造数据，另外构造出两份数据， # 1. X2: 第一份数据则增加两个共线性特征，目的是显著增加其VIF值 # 2. X3: 第二份数据增加两个随机的特征用作对比 X2 = np.column_stack([X1, np.dot(X1[:, [0, 1]], np.array([1, 1])) + np.random.normal(0, 0.05, size=100)]) X2 = np.column_stack([X2, np.dot(X2[:, [1, 2, 3]], np.array([1, 1, 1])) + np.random.normal(0, 0.05, size=100)]) X3 = np.column_stack([X1, np.random.rand(100, 2)]) # 拿这两份数据重新用线性回归拟合模型 lr2 = LinearRegression() lr2.fit(X2[training], y[training]) # 系数的均方误差MSE # 对于第二份共线性构造数据X2，因为多重共线性，可以看到MSE增加了很多，准确率也下降了0.2%： print "lr2 MSE: ", (((lr2.coef_[:8] - coef0) ** 2).sum() / 8) # 测试集准确率（R2） print "lr2 R2: ", (lr2.score(X2[~training], y[~training])) # 平均测试集准确率 print "lr2 MR2: ", (cross_validation.cross_val_score(lr2, X2, y, cv=5).mean()) lr3 = LinearRegression() lr3.fit(X3[training], y[training]) # 系数的均方误差MSE # X3没有明显变化 print "lr3 MSE: ", (((lr3.coef_[:8] - coef0) ** 2).sum() / 8) # 测试集准确率（R2） print "lr3 R2: ", (lr3.score(X3[~training], y[~training])) # 平均测试集准确率 print "lr3 MR2: ", (cross_validation.cross_val_score(lr3, X3, y, cv=5).mean()) # show lr2 VIF result vif2 = np.zeros((10, 1)) for i in range(10): tmp = [k for k in range(10) if k != i] lr2.fit(X2[:, tmp], X2[:, i]) vifi = 1 / (1 - lr2.score(X2[:, tmp], X2[:, i])) vif2[i] = vifi vif3 = np.zeros((10, 1)) for i in range(10): tmp = [k for k in range(10) if k != i] lr2.fit(X3[:, tmp], X3[:, i]) vifi = 1 / (1 - lr2.score(X3[:, tmp], X3[:, i])) vif3[i] = vifi plt.figure() ax = plt.gca() ax.plot(vif2) ax.plot(vif3) plt.xlabel('feature') plt.ylabel('VIF') plt.title('VIF coefficients of the features') plt.axis('tight') plt.show()

https://baike.baidu.com/item/%E6%96%B9%E5%B7%AE%E6%89%A9%E5%A4%A7%E5%9B%A0%E5%AD%90  https://www.jianshu.com/p/0c5066 https://www.jianshu.com/p/ef1b27b8aee0 https://arxiv.org/pdf/1806.06850v1.pdf

# -*- coding: utf-8 -*- import lime import sklearn import numpy as np import sklearn import sklearn.ensemble import sklearn.metrics from sklearn.datasets import fetch_20newsgroups from lime import lime_text from sklearn.pipeline import make_pipeline from lime.lime_text import LimeTextExplainer if __name__ == '__main__': # we'll be using the 20 newsgroups dataset. # In particular, for simplicity, we'll use a 2-class subset: atheism and christianity. categories = ['alt.atheism', 'soc.religion.christian'] newsgroups_train = fetch_20newsgroups(subset='train', categories=categories) newsgroups_test = fetch_20newsgroups(subset='test', categories=categories) class_names = ['atheism', 'christian'] # use the tfidf vectorizer, commonly used for text. vectorizer = sklearn.feature_extraction.text.TfidfVectorizer(lowercase=False) train_vectors = vectorizer.fit_transform(newsgroups_train.data) test_vectors = vectorizer.transform(newsgroups_test.data) # use random forests for classification. # It's usually hard to understand what random forests are doing, especially with many trees. rf = sklearn.ensemble.RandomForestClassifier(n_estimators=500) rf.fit(train_vectors, newsgroups_train.target) pred = rf.predict(test_vectors) print sklearn.metrics.f1_score(newsgroups_test.target, pred, average='binary') # Lime explainers assume that classifiers act on raw text, # but sklearn classifiers act on vectorized representation of texts. # For this purpose, we use sklearn's pipeline, and implements predict_proba on raw_text lists. c = make_pipeline(vectorizer, rf) print(c.predict_proba([newsgroups_test.data[0]])) # Now we create an explainer object. We pass the class_names a an argument for prettier display. explainer = LimeTextExplainer(class_names=class_names) # We then generate an explanation with at most 6 features for an arbitrary document in the test set. idx = 83 exp = explainer.explain_instance(newsgroups_test.data[idx], c.predict_proba, num_features=6) print('Document id: %d' % idx) print('Probability(christian) =', c.predict_proba([newsgroups_test.data[idx]])[0, 1]) print('True class: %s' % class_names[newsgroups_test.target[idx]]) # The classifier got this example right (it predicted atheism). # The explanation is presented below as a list of weighted features. print "exp.as_list(): ", exp.as_list() # These weighted features are a linear model, # which approximates the behaviour of the random forest classifier in the vicinity of the test example. # Roughly, if we remove 'Posting' and 'Host' from the document , # the prediction should move towards the opposite class (Christianity) by about 0.27 (the sum of the weights for both features). # Let's see if this is the case. print('Original prediction:', rf.predict_proba(test_vectors[idx])[0, 1]) tmp = test_vectors[idx].copy() tmp[0, vectorizer.vocabulary_['Posting']] = 0 tmp[0, vectorizer.vocabulary_['Host']] = 0 print('Prediction removing some features:', rf.predict_proba(tmp)[0, 1]) print('Difference:', rf.predict_proba(tmp)[0, 1] - rf.predict_proba(test_vectors[idx])[0, 1]) # Visualizing explanations # The explanations can be returned as a matplotlib barplot: fig = exp.as_pyplot_figure() fig.show() exp.save_to_file('./oi.html')

# -*- coding: utf-8 -*- import matplotlib.pyplot as plt import numpy as np import os import keras import os, sys try: import lime except: sys.path.append(os.path.join('..', '..')) # add the current directory import lime from lime import lime_image from keras.applications import inception_v3 as inc_net from keras.preprocessing import image from keras.applications.imagenet_utils import decode_predictions from skimage.io import imread from skimage.segmentation import mark_boundaries print('run using keras:', keras.__version__) def transform_img_fn(path_list): out = [] for img_path in path_list: img = image.load_img(img_path, target_size=(299, 299)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = inc_net.preprocess_input(x) out.append(x) return np.vstack(out) if __name__ == '__main__': # Using Inception # Here we create a standard InceptionV3 pretrained model, # and use it on images by first preprocessing them with the preprocessing tools inet_model = inc_net.InceptionV3() # Let's see the top 5 prediction for some image img_path = os.path.join('data', 'cat_and_mouse.jpg') print "img_path: ", img_path images = transform_img_fn([img_path]) # I'm dividing by 2 and adding 0.5 because of how this Inception represents images plt.imshow(images[0] / 2 + 0.5) plt.show() preds = inet_model.predict(images) for x in decode_predictions(preds)[0]: print(x) # Explanation # Now let's get an explanation explainer = lime_image.LimeImageExplainer() # hide_color is the color for a superpixel turned OFF. # Alternatively, if it is NONE, the superpixel will be replaced by the average of its pixels. # Here, we set it to 0 (in the representation used by inception model, 0 means gray) explanation = explainer.explain_instance(images[0], inet_model.predict, top_labels=5, hide_color=0, num_samples=1000) # Now let's see the explanation for the Top class # We can see the top 5 superpixels that are most positive towards the class with the rest of the image hidden temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=True) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.show() # Or with the rest of the image present: temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=False) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.show() # We can also see the 'pros and cons' (pros in green, cons in red) temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=10, hide_rest=False) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.show() # Or the pros and cons that have weight at least 0.1 temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=1000, hide_rest=False, min_weight=0.1) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.show() 

# -*- coding: utf-8 -*- import matplotlib.pyplot as plt import numpy as np import pandas as pd from keras.models import Sequential from keras.layers import LSTM, Dropout, Dense from keras.optimizers import Adam from keras.utils import to_categorical from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import classification_report from lime import lime_tabular def reshape_data(seq, n_timesteps): N = len(seq) - n_timesteps - 1 nf = seq.shape[1] if N <= 0: raise ValueError('I need more data!') new_seq = np.zeros((N, n_timesteps, nf)) for i in range(N): new_seq[i, :, :] = seq[i:i+n_timesteps] return new_seq if __name__ == '__main__': # We will use the CO2 dataset, which measures the concentration of CO2 above Mauna Loa every week since about 1960. # The classification task will be deciding if the concentration is rising, # this is a problem that needs recurrency to solve (since the answer comes from the derivative), # and is less trivial than it sounds because there is noise in the data. df = pd.read_csv('data/co2_data.csv', index_col=0, parse_dates=True) fig, (left, right) = plt.subplots(nrows=1, ncols=2, figsize=(13, 5)) df[['co2']].plot(ax=left) df[['co2_detrended']].plot(ax=right) fig.show() # Reshaping the dataset to be appropriate for the model N_TIMESTEPS = 12 # Use 1 year of lookback data_columns = ['co2', 'co2_detrended'] target_columns = ['rising'] scaler = MinMaxScaler(feature_range=(-1, 1)) X_original = scaler.fit_transform(df[data_columns].values) X = reshape_data(X_original, n_timesteps=N_TIMESTEPS) y = to_categorical((df[target_columns].values[N_TIMESTEPS:-1]).astype(int)) # Train on the first 2000, and test on the last 276 samples X_train = X[:2000] y_train = y[:2000] X_test = X[2000:] y_test = y[2000:] print(X.shape, y.shape) # Define the model model = Sequential() model.add(LSTM(32, input_shape=(N_TIMESTEPS, len(data_columns)))) model.add(Dropout(0.2)) model.add(Dense(2, activation='softmax')) optimizer = Adam(lr=1e-4) model.compile(loss='binary_crossentropy', optimizer=optimizer) # train the model model.fit(X_train, y_train, batch_size=100, epochs=100, validation_data=(X_test, y_test), verbose=2) y_pred = np.argmax(model.predict(X_test), axis=1) y_true = np.argmax(y_test, axis=1) print(classification_report(y_true, y_pred)) plt.plot(y_true, lw=3, alpha=0.3, label='Truth') plt.plot(y_pred, '--', label='Predictions') plt.legend(loc='best') plt.show() # Explain the model with LIME explainer = lime_tabular.RecurrentTabularExplainer(X_train, training_labels=y_train, feature_names=data_columns, discretize_continuous=True, class_names=['Falling', 'Rising'], discretizer='decile') exp = explainer.explain_instance(X_test[50], model.predict, num_features=10, labels=(1,)) print exp exp.show_in_notebook()

https://github.com/marcotcr/lime/blob/master/doc/notebooks/Tutorial%20-%20Image%20Classification%20Keras.ipynb  https://arxiv.org/pdf/1602.04938.pdf