def PLOT_DB(lda_first, qda_first, X, y, X_test, y_test):
plt.figure(1)
# Plot the LDA
plt.subplot(1, 2, 1)
plt.subplots_adjust(bottom=0.25, right=0.75)
plot_decision_regions(X=X,
y=y,
clf=lda_first,
colors='limegreen,red',
legend=2)
title_string1 = "Linear Decision Boundry \nAccuracy is : " + str(str(
lda_first.score(X_test, y_test) * 100) + ' %')
plt.title(title_string1)
plt.scatter(lda_first.means_[0][0], qda_first.means_[0][1], c='blue',
marker='+', linewidth='5', s=180, label="Class 0 mean")
plt.scatter(lda_first.means_[1][0], qda_first.means_[1][1], c='yellow',
marker='+', linewidth='5', s=180, label="Class 1 mean")
plt.xlabel("Variable " + '$x_1$')
plt.ylabel("Variable " + '$x_2$')
plt.legend(loc='upper left')
plt.subplot(1, 2, 2)
plt.subplots_adjust(bottom=0.25, right=0.75)
plot_decision_regions(X=X,
y=y,
clf=qda_first,
colors='limegreen,red',
legend=2)
plt.title("Quadratic Decision Boundry \nAccuracy is : " + str(str(
qda_first.score(X_test, y_test) * 100) + ' %'))
plt.scatter(qda_first.means_[0][0], qda_first.means_[0][1], c='blue',
marker='+', linewidth='5', s=180, label="Class 0 mean")
plt.scatter(qda_first.means_[1][0], qda_first.means_[1][1], c='yellow',
marker='+', linewidth='5', s=180, label="Class 1 mean")
plt.xlabel("Variable " + '$x_1$')
plt.ylabel("Variable " + "$x_2$")
plt.legend(loc='upper left')
plt.tight_layout()
plt.xlabel('sepal length ')
plt.ylabel('petal length')
plt.show()
plt.plot(range(1, len(ppn.errors_)+1), ppn.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()"""
import matplotlib.pyplot as plt
from mlxtend.evaluate import plot_decision_regions
# versicolor, virginica, setosa
y2 = df.iloc[45:80, 4].values
y2 = np.where(y2 == 'Iris-virginica', -1, 1)
# sepal width and petal width
X2 = df.iloc[45:80, [1,3]].values
ppn = Perceptron(epochs=10, eta=0.01)
ppn.train(X2, y2)
y2 = df.iloc[0:150, 4].values
y2 = np.where(y2 == 'Iris-virginica', -1, 1)
X2 = df.iloc[0:150, [1,3]].values
plot_decision_regions(X2, y2, clf=ppn)
plt.show()
plt.plot(range(1, len(ppn.errors_)+1), ppn.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
n_features=X.shape[1],
n_hidden=50,
l2=0.00,
l1=0.0,
epochs=300,
eta=0.01,
alpha=0.0,
decrease_const=0.0,
minibatches=1,
shuffle_init=False,
shuffle_epoch=False,
random_seed=1,
print_progress=3)
nn = nn.fit(X, y)
y_pred = nn.predict(X)
acc = np.sum(y == y_pred, axis=0) / X.shape[0]
print('Accuracy: %.2f%%' % (acc * 100))
plot_decision_regions(X, y, clf=nn, legend=2)
plt.title("Logistic regression - gd")
plt.show()
plt.plot(range(len(nn.cost_)), nn.cost_)
plt.ylim([0, 300])
plt.xlabel('Epochs')
plt.ylabel('Cost')
plt.show()
lr = LogisticRegression(eta = 0.1,
l2_lambda=0.0,
epochs=500,
#minibatches=1, # 1 for Gradient Descent
#minibatches=len(y), # len(y) for SGD learning
minibatches=5, # 100/5 = 20 -> minibatch-s
random_seed=1,
print_progress=3)
lr.fit(X, y)
y_pred = lr.predict(X)
print('Last 3 Class Labels: %s' % y_pred[-3:])
y_pred = lr.predict_proba(X)
print('Last 3 Class Labels: %s' % y_pred[-3:])
plot_decision_regions(X, y, clf=lr)
plt.title("Logistic regression - gd")
plt.show()
plt.plot(range(len(lr.cost_)), lr.cost_)
plt.xlabel('Iterations')
plt.ylabel('Cost')
plt.show()
def test_pass():
sr.fit(X[:, :2], y)
plot_decision_regions(X=X[:, :2], y=y, clf=sr)
def test_ylist():
sr.fit(X[:, :2], y)
plot_decision_regions(X=X[:, :2], y=list(y), clf=sr)
X = X[0:100]
y = y[0:100]
X[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std()
X[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std()
lr = LogisticRegression(
eta=0.1,
l2_lambda=0.0,
epochs=500,
#minibatches=1, # 1 for Gradient Descent
#minibatches=len(y), # len(y) for SGD learning
minibatches=5, # 100/5 = 20 -> minibatch-s
random_seed=1,
print_progress=3)
lr.fit(X, y)
y_pred = lr.predict(X)
print('Last 3 Class Labels: %s' % y_pred[-3:])
y_pred = lr.predict_proba(X)
print('Last 3 Class Labels: %s' % y_pred[-3:])
plot_decision_regions(X, y, clf=lr)
plt.title("Logistic regression - gd")
plt.show()
plt.plot(range(len(lr.cost_)), lr.cost_)
plt.xlabel('Iterations')
plt.ylabel('Cost')
plt.show()
import numpy as np
from sklearn.cross_validation import train_test_split, cross_val_score
from sklearn.datasets import load_boston, load_breast_cancer, load_iris, make_moons, make_gaussian_quantiles
from sklearn.metrics import mean_squared_error
from mlxtend.evaluate import plot_decision_regions
import matplotlib.pyplot as plt
from pines.estimators import DecisionTreeRegressor, DecisionTreeClassifier
from pines.tree_builders import TreeType
if __name__ == '__main__':
model = DecisionTreeClassifier(max_n_splits=3, max_depth=10, tree_type=TreeType.OBLIVIOUS)
X, y = make_gaussian_quantiles(n_samples=10000, n_classes=4)
model.fit(X, y)
print(model.tree_)
plot_decision_regions(X, y, clf=model, res=0.02, legend=2)
plt.savefig('decision_boundary.png')
from sklearn.cross_validation import train_test_split
from mlxtend.evaluate import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
# Loading some example data
iris = datasets.load_iris()
X = iris.data[:, [0,2]]
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=0)
# Training a classifier
svm = SVC(C=0.5, kernel='rbf')
svm.fit(X_train, y_train)
# Plotting decision regions
plot_decision_regions(X, y, clf=svm, X_highlight=X_test, res=0.02, legend=2)
# Adding axes annotations
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.title('SVM on Iris')
plt.show()
import matplotlib.pyplot as plt from sklearn import datasets, svm import numpy as np from sklearn.cross_validation import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import Perceptron from sklearn.metrics import accuracy_score from mlxtend.evaluate import plot_decision_regions np.random.seed(0) X_xor = np.random.randn(200, 2) y_xor = np.logical_xor(X_xor[:, 0] > 0, X_xor[:, 1] > 0) y_xor = np.where(y_xor, 1, -1) clf = svm.SVC(kernel='rbf', random_state=0, gamma=0.3, C=10.0) clf.fit(X_xor, y_xor) plot_decision_regions(X_xor, y_xor, clf=clf) # plt.scatter(X_xor[y_xor == 1, 0], X_xor[y_xor == 1, 1], c='b', marker='x', label='1') # plt.scatter(X_xor[y_xor == -1, 0], X_xor[y_xor == -1, 1], c='r', marker='s', label='-1') # plt.ylim(-3.0) # plt.legend() plt.show()
# Gradient Descent
nn1 = MLP(hidden_layers=[50],
l2 = 0.00,
l1 = 0.0,
epochs=150,
eta=0.05,
momentum=0.1,
decrease_const=0.0,
minibatches=1,
random_seed=1,
print_progress=3)
nn1 = nn1.fit(X_std, y)
fig = plot_decision_regions(X=X_std, y=y, clf=nn1, legend=2)
plt.title('Multi-layer perception w. 1 hidden layer (logistic sigmod)')
plt.show()
plt.plot(range(len(nn1.cost_)), nn1.cost_)
plt.ylabel("Cost")
plt.xlabel("Epochs")
plt.show()
print 'Accuracy: %.2f%%' % (100 * nn1.score(X_std, y))
# Stochastic Gradient Descent
nn2 = MLP(hidden_layers=[50],
l2=0.00,
# Gradient Descent
nn1 = TfMultiLayerPerceptron(eta=0.5,
epochs=20,
hidden_layers=[10],
activations=['logistic'],
optimizer='gradientdescent',
print_progress=3,
minibatches=1,
random_seed=1)
nn1 = nn1.fit(X_std, y)
fig = plot_decision_regions(X=X_std, y=y, clf=nn1, legend=2)
plt.title('Multi-layer perception w. 1 hidden layer (logistic sigmod)')
plt.show()
plt.plot(range(len(nn1.cost_)), nn1.cost_)
plt.ylabel("Cost")
plt.xlabel("Epochs")
plt.show()
print 'Accuracy: %.2f%%' % (100 * nn1.score(X_std, y))
# Stochastic Gradient Descent
nn2 = TfMultiLayerPerceptron(eta=0.5,
epochs=20,
update = self.eta * (target - self.predict(xi))
self.w_[1:] += update * xi
self.w_[0] += update
errors += int(update != 0.0)
self.errors_.append(errors)
return self
def net_input(self, X):
return np.dot(X, self.w_[1:]) + self.w_[0]
def predict(self, X):
return np.where(self.net_input(X) >= 0.0, 1, 0)
X = np.array([[-1,-1],[1,1],[-1,1],[1,-1]])
Y = np.array([1,1,0,0])
p = Perceptron(epochs=10, eta=1)
p.train(X, Y)
print('Weights: %s' % p.w_)
plot_decision_regions(X, Y, clf=p)
plt.title('Perceptron')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
plt.plot(range(1, len(p.errors_)+1), p.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
def predict(self, X):
np.sign(np.dot(X, self.weight_vector))
def read_data_set(self):
return np.genfromtxt(self.data_set, delimiter=",", comments="#")
if __name__ == "__main__":
arg_learning_rate = sys.argv[1]
arg_maximum_iterations = sys.argv[2]
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)
# extract sepal length and petal length
X = df.iloc[0:100, [0, 2]].values
perceptron = Perceptron(float(arg_learning_rate), int(arg_maximum_iterations))
perceptron.fit(X, y)
print X
plot_decision_regions(X, y, clf=perceptron)
plt.title('Perceptron')
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.show()
print X
#perceptron.plot(X, y)
# X_test = iris.data[100:]
# print perceptron.predict(X_test)
X = X[:, [0, 3]]
X = X[0:100]
y = y[0:100]
X[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
X[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()
# Closed Form Solution
ada = Adaline(epochs=30,
eta=0.01,
minibatches=None,
random_seed=1)
ada.fit(X, y)
plot_decision_regions(X, y, clf=ada)
plt.title('Adaline - Stochastic Gradient Descent')
plt.show()
# (Stochastic) Gradient Descent
ada2 = Adaline(epochs=30,
eta=0.01,
minibatches=1, # 1 for GD learning
#minibatches=len(y), # len(y) for SGD learning
#minibatches=5, # for SGD learning w. minibatch size 20
random_seed=1,
print_progress=3)
ada2.fit(X, y)
plot_decision_regions(X, y, clf=ada2)
print('y', y)
# sepal length and petal length
X = np.array([[float(r[0]), float(r[2])] for r in df[0:100]])
print('X', X)
ppn = Perceptron(epochs=10, eta=0.01)
#print('ppn', ppn)
ppn.train(X, y)
print('Weights: %s' % ppn.w_)
plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron')
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.show()
plt. clf()
plt.plot(range(1, len(ppn.errors_)+1), ppn.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
# versicolor and virginica
y2 = np.array([-1 if r[4] == 'Iris-virginica' else 1 for r in df[50:150]])
plt.title('Adaline - Learning rate 0.01')
plt.show()
ada = AdalineGD(epochs=10, eta=0.0001).train(X, y)
plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Sum-squared-error')
plt.title('Adaline - Learning rate 0.0001')
plt.show()
#Standardize features
X_std = np.copy(X)
X_std[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std()
X_std[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std()
import matplotlib.pyplot as plt
from mlxtend.evaluate import plot_decision_regions
ada = AdalineGD(epochs=15, eta=0.01)
ada.train(X_std, y)
plot_decision_regions(X_std, y, clf=ada)
plt.title('Adaline - Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.show()
plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Sum-squared-error')
plt.show()
l2 = 0.00,
l1 = 0.0,
epochs = 300,
eta = 0.01,
alpha = 0.0,
decrease_const = 0.0,
minibatches = 1,
shuffle_init = False,
shuffle_epoch = False,
random_seed = 1,
print_progress = 3)
nn = nn.fit(X, y)
y_pred = nn.predict(X)
acc = np.sum(y == y_pred, axis=0) / X.shape[0]
print('Accuracy: %.2f%%' % (acc * 100))
plot_decision_regions(X, y, clf=nn, legend=2)
plt.title("Logistic regression - gd")
plt.show()
plt.plot(range(len(nn.cost_)), nn.cost_)
plt.ylim([0, 300])
plt.xlabel('Epochs')
plt.ylabel('Cost')
plt.show()
random_state=0)
# Feature scaling - computes mean and standard deviation
sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)
# Feed perceptron
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
ppn.fit(X_train_std, y_train)
y_pred = ppn.predict(X_test_std)
print('Missclassified samples: %d' % (y_test != y_pred).sum())
print('Accuracy: %.2f' % accuracy_score(y_test, y_pred))
X_combined_std = np.vstack((X_train_std, X_test_std))
y_combined = np.hstack((y_train, y_test))
print len(X_test.shape)
plot_decision_regions(X_combined_std,
y_combined,
clf=ppn,
res=0.02,
legend=2,
X_highlight=X_test)
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')
plt.show()
'Sample code number', 'Clump Thickness ', 'Uniformity of Cell Size',
'Uniformity of Cell Shape', 'Marginal Adhesion',
'Single Epithelial Cell Size ', 'Bare Nuclei ', 'Bland Chromatin',
'Normal Nucleoli', 'Mitoses', 'Class'
]
data = pd.read_csv('../breast-cancer-wisconsin.data', names=column)
data.replace(to_replace='?', value=np.nan, inplace=True)
data = data.dropna()
x_train, x_test, y_train, x_test = train_test_split(data[column[1:10]],
data[column[10]],
test_size=0.25)
ss_train = StandardScaler()
x_train = ss_train.fit_transform(x_train)
x_test = ss_train.transform(x_test)
lr = LogisticRegression(C=100.0, random_state=1)
lr.fit(x_train, y_train)
plot_decision_regions(X=x_test,
y=x_test,
classifier=lr,
test_idx=range(105, 150))
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')
plt.tight_layout()
# plt.savefig('images/03_06.png', dpi=300)
plt.show()
def test_pass():
sr.fit(X[:, :2], y)
plot_decision_regions(X=X[:, :2], y=y, clf=sr)
import numpy as np
from sklearn.cross_validation import train_test_split, cross_val_score
from sklearn.datasets import load_boston, load_breast_cancer, load_iris, make_moons, make_gaussian_quantiles
from sklearn.metrics import mean_squared_error
from mlxtend.evaluate import plot_decision_regions
import matplotlib.pyplot as plt
from pines.estimators import DecisionTreeRegressor, DecisionTreeClassifier
from pines.tree_builders import TreeType
if __name__ == '__main__':
model = DecisionTreeClassifier(max_n_splits=3,
max_depth=10,
tree_type=TreeType.OBLIVIOUS)
X, y = make_gaussian_quantiles(n_samples=10000, n_classes=4)
model.fit(X, y)
print(model.tree_)
plot_decision_regions(X, y, clf=model, res=0.02, legend=2)
plt.savefig('decision_boundary.png')
def test_y_dim_fail():
sr.fit(X, y)
plot_decision_regions(X=X, y=X, clf=sr)
sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)
# Feed perceptron
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
ppn.fit(X_train_std, y_train)
y_pred = ppn.predict(X_test_std)
print('Missclassified samples: %d' % (y_test != y_pred).sum())
print('Accuracy: %.2f' % accuracy_score(y_test, y_pred))
X_combined_std = np.vstack((X_train_std, X_test_std))
y_combined = np.hstack((y_train, y_test))
print len(X_test.shape)
plot_decision_regions(
X_combined_std,
y_combined,
clf=ppn,
res=0.02,
legend=2,
X_highlight=X_test
)
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')
plt.show()
from sklearn import datasets
import matplotlib.pyplot as plt
import seaborn
from mlxtend.evaluate import plot_decision_regions
import matplotlib.gridspec as gridspec
import itertools
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
iris = datasets.load_iris()
X, y = iris.data[:, 1:3], iris.target
clf1 = LogisticRegression(random_state=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10,8))
for clf, lab, grd in zip([clf1, clf3 ],
['Logistic Regression', 'Naive Bayes'],
itertools.product([0,1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf)
plt.title(lab)
plt.savefig('figure/decision_boundary.svg')
def plot_decision_boundary(self, X, y):
#plot the boundary
plot_decision_regions(X, y, clf = self)
plt.show()
# setosa and versicolor
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)
# sepal length and petal length
X = df.iloc[0:100, [0,2]].values
import matplotlib.pyplot as plt
from mlxtend.evaluate import plot_decision_regions
ppn = Perceptron(epochs=10, eta=0.1)
ppn.train(X, y)
print('Weights: %s' % ppn.w_)
plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron')
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.show()
plt.plot(range(1, len(ppn.errors_)+1), ppn.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
# versicolor and virginica
y2 = df.iloc[50:150, 4].values
y2 = np.where(y2 == 'Iris-virginica', -1, 1)
# sepal width and petal width
update = self.eta * (target - self.predict(xi))
self.w_[1:] += update * xi
self.w_[0] += update
errors += int(update != 0.0)
self.errors_.append(errors)
return self
def net_input(self, X):
return np.dot(X, self.w_[1:]) + self.w_[0]
def predict(self, X):
return np.where(self.net_input(X) >= 0.0, 1, 0)
X = np.array([[-1, -1], [1, 1], [-1, 1], [1, -1]])
Y = np.array([1, 1, 0, 0])
p = Perceptron(epochs=10, eta=1)
p.train(X, Y)
print('Weights: %s' % p.w_)
plot_decision_regions(X, Y, clf=p)
plt.title('Perceptron')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
plt.plot(range(1, len(p.errors_) + 1), p.errors_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
df = pd.read_csv(
'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',
header=None)
#在线获取鸢尾花数据集
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1) #很显然这里对应的是前面的设置的目标的
X = df.iloc[0:100, [0, 2]].values
import matplotlib.pyplot as plt
from mlxtend.evaluate import plot_decision_regions
ppn = Perceptron(epochs=10, eta=0.1)
ppn.train(X, y)
print 'Weight:%s', ppn.w_
plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron')
plt.xlabel('sepal length [cm]')
plt.ylabel('penal length [cm]')
plt.show()
plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='+')
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
########################################
y2 = df.iloc[50:150, 4].values
y2 = np.where(y2 == 'Iris-setosa', -1, 1)
X2 = df.iloc[50:150, [1, 3]].values
ppn = Perceptron(epochs=25, eta=0.01)
from mlxtend.evaluate import plot_decision_regions
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import itertools
clf1 = LogisticRegression(random_state=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
clf4 = SVC()
iris = datasets.load_iris()
X = iris.data[:, [0,2]]
y = iris.target
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10, 8))
for clf, lab, grd in zip([clf1, clf2, clf3, clf4],
['Logistic Regression', 'Random Forest', 'Naive Bayes', 'SVM'],
itertools.product([0, 1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)
plt.title(lab)
plt.show()
from sklearn.ensemble import RandomForestClassifier
from mlxtend.classifier import EnsembleVoteClassifier
from mlxtend.data import iris_data
from mlxtend.evaluate import plot_decision_regions
# Initializing Classifiers
clf1 = LogisticRegression(random_state=0)
clf2 = RandomForestClassifier(random_state=0)
clf3 = SVC(random_state=0, probability=True)
eclf = EnsembleVoteClassifier(clfs=[clf1, clf2, clf3],
weights=[2, 1, 1],
voting='soft')
# Loading some example data
X, y = iris_data()
X = X[:, [0, 2]]
# Plotting Decision Regions
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10, 8))
for clf, lab, grd in zip(
[clf1, clf2, clf3, eclf],
['Logistic Regression', 'Random Forest', 'Naive Bayes', 'Ensemble'],
itertools.product([0, 1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf, legend=2)
plt.title(lab)
plt.show()
import matplotlib.pyplot as plt from sklearn import datasets, svm import numpy as np from sklearn.cross_validation import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import Perceptron from sklearn.metrics import accuracy_score from mlxtend.evaluate import plot_decision_regions np.random.seed(0) X_xor = np.random.randn(200, 2) y_xor = np.logical_xor(X_xor[:, 0] > 0, X_xor[:, 1] > 0) y_xor = np.where(y_xor, 1, -1) clf = svm.SVC(kernel='rbf', random_state=0, gamma=0.3, C=10.0) clf.fit(X_xor, y_xor) plot_decision_regions(X_xor, y_xor, clf=clf) # plt.scatter(X_xor[y_xor == 1, 0], X_xor[y_xor == 1, 1], c='b', marker='x', label='1') # plt.scatter(X_xor[y_xor == -1, 0], X_xor[y_xor == -1, 1], c='r', marker='s', label='-1') # plt.ylim(-3.0) # plt.legend() plt.show()
from mlxtend.evaluate import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
# Loading some example data
iris = datasets.load_iris()
X = iris.data[:, [0,2]]
y = iris.target
# Training a classifier
svm = SVC(C=0.5, kernel='linear')
svm.fit(X,y)
# Plotting decision regions
plot_decision_regions(X, y, clf=svm, res=0.02, legend=2)
# Adding axes annotations
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.title('SVM on Iris')
plt.show()
# Loading Data
X, y = iris_data()
X = X[:, [0, 3]] # sepal length and petal width
X = X[0:100] # class 0 and class 1
y = y[0:100] # class 0 and class 1
# standardize
X[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
X[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()
# Note that this implementation of the Perceptron expects binary class labels in {0, 1}.
# Rosenblatt Perceptron
ppn = Perceptron(epochs=5, # num of passes, default 50
eta=0.05, # learning rate 0.0 ~ 1.0, default 0.1
random_seed=0,
print_progress=3)
ppn.fit(X, y)
plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron - Rosenblatt Perceptron Rule')
plt.show()
print('Bias & Weights: %s' % ppn.w_)
plt.plot(range(len(ppn.cost_)), ppn.cost_)
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()
y,
cv=3,
scoring='accuracy')
print 'Accuracy: %0.2f (+/- %0.2f [%s]' % (scores.mean(), scores.std(),
label)
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10, 8))
for clf, lab, grd in zip(
[clf1, clf2, clf3, sclf],
['KNN', 'Random Forest', 'Naive bayes', 'StackingClassifier'],
itertools.product([0, 1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf)
plt.title(lab)
plt.show()
# Stacked classification and grid search
params = {
'kneighborsclassifier__n_neighbors': [1, 5],
'randomforestclassifier__n_estimators': [10, 50],
'meta-logisticregression__C': [0.1, 10.0]
}
grid = GridSearchCV(estimator=sclf, param_grid=params, cv=5, refit=True)
grid.fit(X, y)
from mlxtend.evaluate import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
# Loading some example data
iris = datasets.load_iris()
X = iris.data[:, 2]
X = X[:, None]
y = iris.target
# Training a classifier
svm = SVC(C=0.5, kernel='linear')
svm.fit(X,y)
# Plotting decision regions
plot_decision_regions(X, y, clf=svm, res=0.02, legend=2)
# Adding axes annotations
plt.xlabel('sepal length [cm]')
plt.title('SVM on Iris')
plt.show()
X_std[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()
# # choose different learning rate
# ada = AdalineGD(iter_num=10, alpha=0.01).train(X, y)
# plt.plot(range(1, len(ada.cost_)+1), np.log10(ada.cost_), marker='o')
# plt.xlabel('Iterations')
# plt.ylabel('log(Sum-squared-error)')
# plt.title('Adaline - Learning rate 0.01')
# plt.show()
# ada = AdalineGD(iter_num=10, alpha=0.0001).train(X, y)
# plt.plot(range(1, len(ada.cost_)+1), ada.cost_, marker='o')
# plt.xlabel('Iterations')
# plt.ylabel('Sum-squared-error')
# plt.title('Adaline - Learning rate 0.0001')
# plt.show()
ada = AdalineGD(iter_num=15, alpha=0.01)
ada.train(X_std, y)
plot_decision_regions(X_std, y, clf=ada)
plt.title('Adaline - Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.show()
plt.plot(range(1, len( ada.cost_)+1), ada.cost_, marker='o')
plt.xlabel('Iterations')
plt.ylabel('Sum-squared-error')
plt.show()
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
from IPython.display import Image
# <codecell>
iris = datasets.load_iris()
x = iris.data[:,[0,2]]
y = iris.target
svm = SVC(C=0.5,kernel='linear')
svm.fit(x,y)
# <codecell>
plot_decision_regions(x,y,clf = svm, res=0.1,legend = 2)
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.title('SVM on Iris')
plt.show()
# <markdowncell>
# # 问题
#
# ## 这里是x.shape[1] 必须等于2，目前没有处理高维数据的。
# <codecell>