def test_invalid_class(): ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) try: ppn.fit(X, y2) # -2, 1 class assert (1 == 2) except ValueError: pass
def test_standardized_iris_data(): t1 = np.array([0.18, 0.41, 0.50]) ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn.fit(X_std, y1) # -1, 1 class assert ((y1 == ppn.predict(X_std)).all())
def test_standardized_iris_data(): t1 = np.array([0.18, 0.41, 0.50]) ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn.fit(X_std, y1) # -1, 1 class assert((y1 == ppn.predict(X_std)).all())
def test_invalid_class(): ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) try: ppn.fit(X, y2) # -2, 1 class assert 1 == 2 except ValueError: pass
def __init__(self, eta=0.1, epochs=50, random_seed=None, print_progress=0): epochs = int(epochs) warnings.filterwarnings(module='mlxtend*', action='ignore', category=FutureWarning) _Perceptron.__init__(self, eta, epochs, random_seed, print_progress) BaseWrapperClf.__init__(self)
def test_invalid_labels_2(): y1 = np.where(y0 == 0, -1, 1) ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) assert_raises(AttributeError, 'y array must not contain negative labels.\nFound [-1 1]', ppn.fit, X, y1, {(-1, 1)})
def test_invalid_labels_1(): y1 = np.where(y0 == 0, 2, 1) ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) assert_raises(AttributeError, 'Labels not in {(0, 1)}.\nFound (1, 2)', ppn.fit, X, y1, {(0, 1)})
def test_invalid_labels_1(): y1 = np.where(y0 == 0, 2, 1) ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) if sys.version_info >= (3, 0): objtype = '{(0, 1)}' else: objtype = 'set([(0, 1)])' expect = 'Labels not in %s.\nFound (1, 2)' % objtype assert_raises(AttributeError, expect, ppn.fit, X, y1, {(0, 1)})
def test_0_1_class_iris_data(): t1 = np.array([0.26, -0. , 0.27]) ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) ppn.fit(X, y0) # 0, 1 class assert((y0 == ppn.predict(X)).all())
from mlxtend.evaluate import plot_decision_regions #! ImportError: cannot import name 'plot_decision_regions' from mlxtend.classifier import Perceptron from mlxtend.classifier import Adaline from mlxtend.classifier import MultiLayerPerceptron import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_moons import matplotlib.gridspec as gridspec import itertools gs = gridspec.GridSpec(2, 2) #xw X, y = make_moons(n_samples=100, random_state=123) fig = plt.figure(figsize=(10, 8)) ppn = Perceptron(epochs=50, eta=0.05, random_seed=0) ppn.fit(X, y) ada = Adaline(epochs=50, eta=0.05, random_seed=0) ada.fit(X, y) mlp = MultiLayerPerceptron(n_output=len(np.unique(y)), n_features=X.shape[1], n_hidden=150, l2=0.0, l1=0.0, epochs=500, eta=0.01, alpha=0.0, decrease_const=0.0, minibatches=1, shuffle_init=False,
# Author: Sebastian Raschka <sebastianraschka.com> # # License: BSD 3 clause from mlxtend.classifier import Perceptron from mlxtend.data import iris_data import numpy as np from nose.tools import raises # Iris Data X, y = iris_data() X = X[:, [0, 3]] # sepal length and petal width X = X[0:100] # class 0 and class 1 y0 = y[0:100] # class 0 and class 1 y1 = np.where(y[0:100] == 0, -1, 1) # class -1 and class 1 y2 = np.where(y[0:100] == 0, -2, 1) # class -2 and class 1 # standardize 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() ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn = ppn.fit(X_std, y1) # -1, 1 class assert((y1 == ppn.predict(X_std)).all()) test_standardized_iris_data()
def test_array_dimensions(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn = ppn.fit(np.array([1, 2, 3]), [-1])
def test_standardized_iris_data_with_zero_weights(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1, zero_init_weight=True) ppn = ppn.fit(X_std, y1) # -1, 1 class assert (y1 == ppn.predict(X_std)).all()
def test_progress_3(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1, print_progress=3) ppn = ppn.fit(X_std, y0)
def test_nonstandardized_iris_data(): ppn = Perceptron(epochs=100, eta=0.01, random_seed=1) ppn = ppn.fit(X, y0) assert (y0 == ppn.predict(X)).all()
# 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()
def test_nonstandardized_iris_data(): t1 = np.array([0.078, -0.074, 0.46]) ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) ppn.fit(X, y1) # -1, 1 class assert ((y1 == ppn.predict(X)).all())
def test_nonstandardized_iris_data(): t1 = np.array([0.078, -0.074, 0.46]) ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) ppn.fit(X, y1) # -1, 1 class assert((y1 == ppn.predict(X)).all())
def test_score_function(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1, shuffle=True) ppn = ppn.fit(X_std, y1) # -1, 1 class acc = ppn.score(X_std, y1) assert acc == 1.0, acc
def test_ary_persistency_in_shuffling(): orig = X.copy() ppn = Perceptron(epochs=40, eta=0.05, random_seed=1) ppn = ppn.fit(X, y0) # 0, 1 class np.testing.assert_almost_equal(orig, X, 6)
# 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()
def test_standardized_iris_data(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn = ppn.fit(X_std, y0) assert (y0 == ppn.predict(X_std)).all(), ppn.predict(X_std)
def test_standardized_iris_data_with_shuffle(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1, shuffle=True) ppn = ppn.fit(X_std, y1) # -1, 1 class assert (y1 == ppn.predict(X_std)).all()
def test_score_function(): ppn = Perceptron(epochs=15, eta=0.01, random_seed=1) ppn = ppn.fit(X_std, y0) acc = ppn.score(X_std, y0) assert acc == 1.0, acc
def test_clone(): ppn = Perceptron() clone(ppn)
def test_0_1_class_iris_data(): ppn = Perceptron(epochs=40, eta=0.05, random_seed=1) ppn = ppn.fit(X, y0) # 0, 1 class print(y0) print(ppn.predict(X)) assert (y0 == ppn.predict(X)).all()
from mlxtend.data import iris_data from mlxtend.plotting import plot_decision_regions from mlxtend.classifier import Perceptron import matplotlib.pyplot as plt import numpy as np # Loading Data X, y = iris_data() X = X[:, [0, 3]] # sepal length and petal width #print(X) X = X[0:100] # class 0 and class 1 print(X.shape) y = y[0:100] # class 0 and class 1 print(y.shape) # standardize X[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std() X[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std() print(X) # Rosenblatt Perceptron ppn = Perceptron(epochs=5, eta=0.05, random_seed=0, print_progress=3) ppn.fit(X, y) x2=np.array([[0.35866332 ,0.91401319],[5.7,1.3]]) print("\n",ppn.predict(x2))
def test_0_1_class_iris_data(): t1 = np.array([0.26, -0., 0.27]) ppn = Perceptron(epochs=40, eta=0.01, random_seed=1) ppn.fit(X, y0) # 0, 1 class assert ((y0 == ppn.predict(X)).all())
# Loading Data X, y = wine_data() X = X[:, [3, 12]] # hue, ash 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() # Rosenblatt Perceptron ppn = Perceptron(epochs=500, eta=0.05, random_seed=1, print_progress=3) ppn.fit(X, y) plot_decision_regions(X, y, clf=ppn) plt.title('Wine Data - Hue and Ash 500 Epochs') plt.show() print('Bias & Weights: %s' % ppn.w_) plt.plot(range(len(ppn.cost_)), ppn.cost_) plt.xlabel('Iterations') plt.ylabel('Missclassifications') plt.show()
def identificador(self): w_prueba = [] Elementos = [self.word, self.comparar] auxiliar_contador = 0 for j in Elementos: if len(self.word) <= len(j): for i in range(len(self.word)): if self.word[i] == j[i]: w_prueba.append(1) else: w_prueba.append(0) else: for i in range(len(j)): if self.word[i] == j[i]: w_prueba.append(1) else: w_prueba.append(0) #print (w_prueba) #print(sum(w_prueba[:len(self.word)])) auxiliar_x = sum(w_prueba[:len(self.word)]) #print(auxiliar_x) auxiliar_x2 = sum(w_prueba[len(self.word):len(self.word) + len(self.comparar)]) #print(auxiliar_x2) X = np.array([[len(self.word), sum(w_prueba[:len(self.word)])], [len(self.word), sum(w_prueba[:len(self.word)])], [len(self.word), sum(w_prueba[1:len(self.word)])], [len(self.word), sum(w_prueba[1:len(self.word)])], [len(self.word) + 1, len(self.word) - 1], [len(self.word) - 1, len(self.word) - 1], [len(self.word) + 1, len(self.word) - 2], [len(self.word) - 1, len(self.word) - 2]]) #print(X[:,0]) X[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std() X[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std() y = np.array([0, 0, 0, 0, 1, 1, 1, 1]) #print(X) #print(y) ppn = Perceptron(epochs=5, eta=0.05, random_seed=0, print_progress=3) ppn.fit(X, y) X2 = (np.array([[len(self.word), auxiliar_x], [len(self.word) + 1, len(self.word) - 1], [len(self.comparar), auxiliar_x2]])) #print("\n",X2[:,0].std()) #print("\n",X2[:,1].std()) X2[:, 0] = (X2[:, 0] - X2[:, 0].mean()) / X2[:, 0].std() X2[:, 1] = (X2[:, 1] - X2[:, 1].mean()) / X2[:, 1].std() #print(X2) #print("\n",ppn.predict(X2)) resultado = ppn.predict(X2) self.encontro = resultado[2] print("\n\n") a = os.system("clear") return self.encontro