def test_mlp(): X_train, y_train = load_mnist('./data', 'train') # Validate row and column count on train data print('Rows: {}, columns: {}'.format(X_train.shape[0], X_train.shape[1])) if int(X_train.shape[0]) != 60000: print('Rows invalid -- FAIL') if int(X_train.shape[1]) != 784: print('Columns invalid -- FAIL') # Validate row and column count on test data X_test, y_test = load_mnist('./data', 't10k') print('Rows: {}, columns: {}'.format(X_test.shape[0], X_test.shape[1])) if int(X_test.shape[0]) != 10000: print('Rows invalid -- FAIL') if int(X_test.shape[1]) != 784: print('Columns invalid -- FAIL') # Validate the image integrity is retained fig, ax = plt.subplots(nrows=2, ncols=5, sharex=True, sharey=True) ax = ax.flatten() for i in range(10): img = X_train[y_train == i][0].reshape(28, 28) ax[i].imshow(img, cmap='Greys') ax[0].set_xticks([]) ax[0].set_yticks([]) plt.tight_layout() plt.show() # Compress the data for portability np.savez_compressed('mnist_scaled.npz', X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test) mlp = MultiLayerPerceptron(n_hidden=100, l2=0.01, epochs=200, eta=0.0005, minibatch_size=100, shuffle=True, seed=1) # Train the network mlp.fit(X_train=X_train[:55000], y_train=y_train[:55000], X_valid=X_train[55000:], y_valid=y_train[55000:]) # Visualize the output plt.plot(range(mlp.epochs), mlp.eval_['cost']) plt.ylabel('Cost') plt.xlabel('Epochs') plt.show()
def setUp(self): unittest.TestCase.setUp(self) self.params = {'neuronsByLayer': [2], \ 'learningRate': 0.2, \ 'numSamples': 4, \ 'trainingPercentage': 1.0, \ 'beta': 3.0} self.inputs = [[0,0], [0,1], [1,0], [1,1]] self.biasedInputs = [[0,0,-1], [0,1,-1], [1,0,-1], [1,1,-1]] self.targets = [[0],[1],[1], [0]] self.weights =[[[1,1],[1,1], [0.5,1]],[[1],[-1],[0.5]]] (copyParams, copyInputs) = copy.deepcopy((self.params, self.inputs)) self.percepter = MultiLayerPerceptron(copyParams, copyInputs)
def __init__(self, num_envstate_dims, num_action_dims, hidden_layer_sizes, criterion=nn.MSELoss(), lr=4e-4, activation=f.selu, seed=0): torch.manual_seed(seed) super(BehaviorCloningModel, self).__init__() self.mlp = MultiLayerPerceptron(in_features=num_envstate_dims, hidden_layer_sizes=hidden_layer_sizes + [num_action_dims], activation=activation) self.criterion = criterion self.optimizer = optim.Adam(self.mlp.parameters(), lr=lr)
class PerceptronTests(unittest.TestCase): def setUp(self): unittest.TestCase.setUp(self) self.params = {'neuronsByLayer': [2], \ 'learningRate': 0.2, \ 'numSamples': 4, \ 'trainingPercentage': 1.0, \ 'beta': 3.0} self.inputs = [[0,0], [0,1], [1,0], [1,1]] self.biasedInputs = [[0,0,-1], [0,1,-1], [1,0,-1], [1,1,-1]] self.targets = [[0],[1],[1], [0]] self.weights =[[[1,1],[1,1], [0.5,1]],[[1],[-1],[0.5]]] (copyParams, copyInputs) = copy.deepcopy((self.params, self.inputs)) self.percepter = MultiLayerPerceptron(copyParams, copyInputs) def testConstructor(self): (copyParams, copyInputs) = copy.deepcopy((self.params, self.inputs)) testPercepter = MultiLayerPerceptron(copyParams, copyInputs) expectedParams = list(map(lambda x:x+1, self.params['neuronsByLayer'])) self.assertListEqual(expectedParams, testPercepter.params['neuronsByLayer']) self.assertListEqual(self.biasedInputs, testPercepter.inputs) def testInitializeWeights(self): weights = self.percepter.initializeWeights(len(self.biasedInputs[0]), self.percepter.params['neuronsByLayer'], 1) #count number of hidden layers + output layer self.assertEqual(len(weights), len(self.weights)) for i in range(len(self.weights)): self.assertEqual(len(weights[i]), len(self.weights[i])) for j in range(len(self.weights[i])): self.assertEqual(len(weights[i][j]), len(self.weights[i][j]))
def __init__(self, num_envstate_dims, num_action_dims, hidden_layer_sizes, activation=f.selu, seed=0): torch.manual_seed(seed) super(BehaviorCloningModel, self).__init__() self.mlp = MultiLayerPerceptron(in_features=num_envstate_dims, hidden_layer_sizes=hidden_layer_sizes + [num_action_dims], activation=activation)
def open(self,*args,**kwargs): image_list,teacher_data = get_data() self.mlp = MultiLayerPerceptron(len(image_list[0]), len(image_list[0]), len(teacher_data[0]), "tanh", "sigmoid") pass
class FaceDetectionHandler(tornado.websocket.WebSocketHandler): supports_binary = True def open(self,*args,**kwargs): image_list,teacher_data = get_data() self.mlp = MultiLayerPerceptron(len(image_list[0]), len(image_list[0]), len(teacher_data[0]), "tanh", "sigmoid") pass def on_message(self,message): message = json.loads(message) #print type(message) #print len(message) #print np.array(message,dtype="uint8") message = np.resize(np.array(message,dtype="uint8"),(100,100)) #gray, detected_faces = self.detect_face(message) #face_index = 0 #plt.imshow(gray,cmap='Greys_r') #plt.show() #print gray #print detected_faces,"d" # predict output #for face in detected_faces: # (x, y, w, h) = face #print "found!!" #print x,y,w,h #extracted_face = self.extract_face_features(gray, face, (0.03, 0.05)) #(0.075, 0.05) output = self.predict(message) print output #self.write_message(json.dumps({"x":int(x),"y":int(y),"w":int(w),"h":int(h)})) #plt.imshow(message,cmap="gray") #plt.show() def detect_face(self,gray): cascPath = "data/haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascPath) #gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) detected_faces = faceCascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=6, minSize=(10, 10), flags=cv2.cv.CV_HAAR_SCALE_IMAGE ) return gray, detected_faces ''' def extract_face_features(self,gray, detected_face, offset_coefficients): (x, y, w, h) = detected_face horizontal_offset = offset_coefficients[0] * w vertical_offset = offset_coefficients[1] * h extracted_face = gray[y+vertical_offset:y+h, x+horizontal_offset:x-horizontal_offset+w] new_extracted_face = zoom(extracted_face, (64. / extracted_face.shape[0], 64. / extracted_face.shape[1])) new_extracted_face = new_extracted_face.astype(float32) new_extracted_face /= float(new_extracted_face.max()) return new_extracted_face ''' def predict(self,face): self.mlp.predict_from_stored_weight(face) return
# ファイルの作成 # precision preMat = open("./precision/preMat" + str(loop) + ".csv", "w") preMat = csv.writer(preMat) # recall recMat = open("./recall/recMat" + str(loop) + ".csv", "w") recMat = csv.writer(recMat) # fscore fscMat = open("./F-score/fscMat" + str(loop) + ".csv", "w") fscMat = csv.writer(fscMat) # 多層パーセプトロンを構築 mlp = MultiLayerPerceptron(28 * 28, 1000, 10, act1="tanh", act2="softmax", preMat=preMat, recMat=recMat, fscMat=fscMat) ##################### # 0~9の全てのデータ ##################### # 訓練データとテストデータに分解 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) # 教師信号の数字を1-of-K表記に変換(全てのデータ) labels_train = LabelBinarizer().fit_transform(y_train)
from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.preprocessing import OneHotEncoder from mlp import MultiLayerPerceptron import numpy as np iris = datasets.load_iris() x = iris.data y = iris.target[:, np.newaxis] np.random.shuffle(x) np.random.shuffle(y) x -= np.mean(x) x /= np.max(x) x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.20, random_state=0) onehot_encoder = OneHotEncoder(sparse=False, categories='auto') y_train = onehot_encoder.fit_transform(y_train) mlp = MultiLayerPerceptron(x_train.shape[1], [10, 3]) mlp.fit(x_train.T, y_train.T, 0.01, 10000) print(mlp.accuracy(x_test.T, y_test.T))
class BehaviorCloningModel(nn.Module): """ Model predicts action given state of the environment """ def __init__(self, num_envstate_dims, num_action_dims, hidden_layer_sizes, criterion=nn.MSELoss(), lr=4e-4, activation=f.selu, seed=0): torch.manual_seed(seed) super(BehaviorCloningModel, self).__init__() self.mlp = MultiLayerPerceptron(in_features=num_envstate_dims, hidden_layer_sizes=hidden_layer_sizes + [num_action_dims], activation=activation) self.criterion = criterion self.optimizer = optim.Adam(self.mlp.parameters(), lr=lr) def forward(self, state): return self.mlp(state) def train_and_validate(self, train_dl, valid_dl, num_epochs): loss_list = [] avg_loss_list = [] valid_loss_list = [] logger.info("Starting with epoch 0") for epoch in range(num_epochs): losses_for_given_epoch = [] self.mlp.train() for states, actions in train_dl: states = states.float() actions = actions.float() self.optimizer.zero_grad() # Generate predictions pred_actions = self.mlp(states) loss = self.criterion(pred_actions, actions) loss.backward() self.optimizer.step() losses_for_given_epoch.append(loss.item()) self.mlp.eval() with torch.no_grad(): valid_loss_sum = 0 for states, actions in valid_dl: states = states.float() actions = actions.float() pred_actions = self.mlp(states) valid_loss_sum += self.criterion(pred_actions, actions) valid_loss = valid_loss_sum / len(valid_dl) loss_list += losses_for_given_epoch avg_loss_list.append(np.mean(losses_for_given_epoch)) valid_loss_list.append(valid_loss) logger.info(f'Completed epoch: {epoch}/{num_epochs}') logger.info( f'Avg loss this epoch: {np.mean(losses_for_given_epoch)}') logger.info(f'Validation loss this epoch: {valid_loss}') return loss_list, avg_loss_list, valid_loss_list
# shuffle rows df = df.reindex(np.random.permutation(df.index)) from mlp import MultiLayerPerceptron X = df.iloc[0:150, [0, 1, 2, 3]].values y = df.iloc[0:150, 4].values training_X = df.iloc[0:100, [0, 1, 2, 3]].values testing_X = df.iloc[101:150, [0, 1, 2, 3]].values training_y = df.iloc[0:100, 4].values training_y = np.where(training_y == 'Iris-setosa', -1, 1) testing_y = df.iloc[101:150, 4].values testing_y = np.where(testing_y == 'Iris-setosa', -1, 1) perceptron = MultiLayerPerceptron(iteration_count=100) perceptron.fit(training_X, training_y) print perceptron.w_ # final parameters print "" print "Predicted" print perceptron.predict(testing_X) print "" print "Actual" print testing_y
if testing == "sin": factory.generate_sin_values(inputs[testing], target[testing]) output = np.zeros(target[testing].shape) options = { "xor": { "number_inputs": number_inputs, "number_hidden_units": number_hidden_units, "number_outputs": number_outputs, "activation_type": activation_type }, "sin": factory.sin_finder(activation_type) } nn = MultiLayerPerceptron(options[testing]) for epoch in range(max_epochs): error = 0 for index, value in enumerate(inputs[testing]): output[index] = nn.forward(value) error += nn.backward(target[testing][index]) nn.update_weights(learning_rate[activation_type]) if epoch % 100 == 0: print('Epoch:\t{}\tError:\t{}'.format(epoch, error)) learning_rate[activation_type] *= learning_rate_change[activation_type] if testing == "xor": print('Output: {0}'.format(output)) print('Average difference between target and output: {0}'.format( nn.average_miss(target[testing], output)))
from mlp import MultiLayerPerceptron TEST_PATH = "data/test.csv" TRAIN_PATH = "data/train.csv" test_set = TestSet(TEST_PATH).read() train_set = TrainSet(TRAIN_PATH).read() x_train = train_set.drop("label", axis=1).values.astype('float32') y_train = train_set["label"].values.astype('int32') #preprocessing max_value = np.max(x_train) mean_value = np.mean(x_train) test_set = (test_set - mean_value) / max_value x_train = (x_train - mean_value) / max_value #MLP MLP_SUBMISSION = "mlp.csv" mlp = MultiLayerPerceptron(x_train, y_train) mlp.fit() predictions = mlp.predict(test_set) Submission(predictions).save(MLP_SUBMISSION) for i in range(1, 10): random_image = test_set[i,:] print(predictions[i]) Pixel(random_image).display()
# ファイルの作成 # precision_recall_fscore_support preMat = open("./precision/preMat" + str(loop) + ".csv", "w") preMat = csv.writer(preMat) # recall recMat = open("./recall/recMat" + str(loop) + ".csv", "w") recMat = csv.writer(recMat) # fscore fscMat = open("./F-score/fscMat" + str(loop) + ".csv", "w") fscMat = csv.writer(fscMat) # 多層パーセプトロンを構築 mlp = MultiLayerPerceptron(28 * 28, 200, 10, act1="sigmoid", act2="softmax", preMat=preMat, recMat=recMat, fscMat=fscMat) #------------------------------- # 訓練データ、テストデータを用意する #------------------------------- # 全ての数字を含むテスト用のデータを用意 # 訓練データとテストデータに分解 (使うのはテストデータのみ) X_train_all, X_test_all, y_train_all, y_test_all = train_test_split( X, y, test_size=0.1) # 4を覗いたインデックスを取得 index_without4 = np.where((y != 4)) # 4を除いたインデックスの教師信号を取得
"optimizer": torch.optim.SGD, "loss_fnc": torch.nn.MSELoss(), "plot": True } opts.update(args_dict) # label information label_name = "income" label_mapping = {'<=50K': 0, '>50K': 1} # random seed if not opts.seed is None: torch.manual_seed(opts.seed) # load data # You only have to call this once, then it'll save the preprocessed data into a new .csv file train_loader, valid_loader = load_data( "../data/adult.csv", label_name, label_mapping, preprocess=True, batch_size=opts.batch_size, seed=opts.seed) # Then you can just call it like this, which should make thing run faster #train_loader, valid_loader = load_data( "../data/adult_preprocessed.csv", label_name, label_mapping, # preprocess=False, batch_size=opts.batch_size, seed=opts.seed) # creating model input_size = len(train_loader.dataset.data[0, :]) output_size = 1 model = MultiLayerPerceptron(input_size, output_size, """other parameters""") # training model final_statistics = train(model, train_loader, valid_loader, opts)
df = df.reindex(np.random.permutation(df.index)) from mlp import MultiLayerPerceptron X = df.iloc[0:150, [0, 1, 2, 3]].values y = df.iloc[0:150, 4].values training_X = df.iloc[0:100, [0, 1, 2, 3]].values testing_X = df.iloc[101:150, [0, 1, 2, 3]].values training_y = df.iloc[0:100, 4].values training_y = np.where(training_y == 'Iris-setosa', -1, 1) testing_y = df.iloc[101:150, 4].values testing_y = np.where(testing_y == 'Iris-setosa', -1, 1) perceptron = MultiLayerPerceptron(iteration_count=100) perceptron.fit(training_X, training_y) print perceptron.w_ # final parameters print "" print "Predicted" print perceptron.predict(testing_X) print "" print "Actual" print testing_y
http://scikit-learn.org/ """ if __name__ == "__main__": # scikit-learnの簡易数字データをロード # 1797サンプル, 8x8ピクセル digits = load_digits() # 訓練データを作成 X = digits.data y = digits.target # ピクセルの値を0.0-1.0に正規化 X /= X.max() # 多層パーセプトロン mlp = MultiLayerPerceptron(64, 100, 10, act1="tanh", act2="sigmoid") # 訓練データ(90%)とテストデータ(10%)に分解 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) # 教師信号の数字を1-of-K表記に変換 # 0 => [1, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 1 => [0, 1, 0, 0, 0, 0, 0, 0, 0, 0] # ... # 9 => [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] labels_train = LabelBinarizer().fit_transform(y_train) labels_test = LabelBinarizer().fit_transform(y_test) # 訓練データを用いてニューラルネットの重みを学習 mlp.fit(X_train, labels_train, learning_rate=0.01, epochs=10000)
""" if __name__ == "__main__": # scikit-learnの簡易数字データをロード # 1797サンプル, 8x8ピクセル digits = load_digits() # 訓練データを作成 X = digits.data y = digits.target # ピクセルの値を0.0-1.0に正規化 X /= X.max() # 多層パーセプトロン mlp = MultiLayerPerceptron(64, 100, 10, act1="sigmoid", act2="sigmoid") # 訓練データ(90%)とテストデータ(10%)に分解 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) # 教師信号の数字を1-of-K表記に変換 # 0 => [1, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 1 => [0, 1, 0, 0, 0, 0, 0, 0, 0, 0] # ... # 9 => [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] labels_train = LabelBinarizer().fit_transform(y_train) labels_test = LabelBinarizer().fit_transform(y_test) # 訓練データを用いてニューラルネットの重みを学習 mlp.fit(X_train, labels_train, epochs=10000)
from mlp import MultiLayerPerceptron mlp = MultiLayerPerceptron() mlp.printModel()
def main(): data = pd.read_csv('blood.csv') x_train = data.drop(['a'], axis=1) y_train = data['a'] x_train = pd.get_dummies(x_train) target_map = dict() if y_train.dtype == 'object': target_map = {val: i for (i, val) in enumerate(np.unique(y_train))} # print(target_map) y_train = y_train.map(target_map) y_train = to_categorical(y_train) # print(y_train[:5]) x_train = x_train.values # x_train = (x_train - x_train.min(axis=0)) / (x_train.max(axis=0) - x_train.min(axis=0)) # x_train = (x_train - x_train.mean(axis=0)) / np.std(x_train, axis=0) x_train, x_test, y_train, y_test = train_test_split(x_train, y_train, test_size=0.2) mean_train = x_train.mean(axis=0) std_train = np.std(x_train, axis=0) x_train = (x_train - mean_train)/std_train x_test = (x_test - mean_train)/std_train mlp = MultiLayerPerceptron() mlp.add(Input(x_train.shape[1])) mlp.add(Dense(32, activation='relu')) mlp.add(Dense(2, activation='sigmoid')) mlp.build() mlp.fit(x_train, y_train, epoch=40, lr=0.05, validation_data=(x_test, y_test)) mlp.draw()
def runMyMLP(params, inputs, objective): percepter = MultiLayerPerceptron(params, inputs) percepter.train(objective.outputDim)
def main(): data = pd.read_csv("blood.csv") x_train = data.drop(["a"], axis=1) y_train = data["a"] x_train = pd.get_dummies(x_train) target_map = dict() if y_train.dtype == "object": target_map = {val: i for (i, val) in enumerate(np.unique(y_train))} y_train = y_train.map(target_map) y_train = to_categorical(y_train) x_train = x_train.values x_train, x_test, y_train, y_test = train_test_split(x_train, y_train, test_size=0.2) mean_train = x_train.mean(axis=0) std_train = np.std(x_train, axis=0) x_train = (x_train - mean_train) / std_train x_test = (x_test - mean_train) / std_train mlp = MultiLayerPerceptron() mlp.add(Input(x_train.shape[1])) mlp.add(Dense(32, activation="relu")) mlp.add(Dense(2, activation="sigmoid")) mlp.build() mlp.fit(x_train, y_train, epoch=40, lr=0.05, validation_data=(x_test, y_test)) mlp.draw()
for loop in range(aveLoop): print "***",loop,"***" # ファイルの作成 # precision preMat = open("./precision/preMat"+str(loop)+".csv", "w") preMat = csv.writer(preMat) # recall recMat = open("./recall/recMat"+str(loop)+".csv", "w") recMat = csv.writer(recMat) # fscore fscMat = open("./F-score/fscMat"+str(loop)+".csv", "w") fscMat = csv.writer(fscMat) # 多層パーセプトロンを構築 mlp = MultiLayerPerceptron(28*28, 1000, 10, act1="tanh", act2="softmax", preMat=preMat, recMat=recMat, fscMat=fscMat) #------------------------------- # 訓練データ、テストデータを用意する #------------------------------- # 全ての数字を含むテスト用のデータを用意 # 訓練データとテストデータに分解 (使うのはテストデータのみ) X_train_all, X_test_all, y_train_all, y_test_all = train_test_split(X, y, test_size=0.1) # 4を除いたインデックスを取得 index_without4 = np.where((y != 4)) # 4を除いたインデックスの教師信号を取得 y_without4 = y[index_without4] # 4を除いたインデックスの入力を取得 X_without4 = X[index_without4]
import numpy as np from mlp import MultiLayerPerceptron mlp = MultiLayerPerceptron( numero_de_entradas=2, neuronios_por_camada=[2, 2], pesos=[[np.array([0.35, 0.15, 0.2]), np.array([0.35, 0.25, 0.3])], [np.array([0.6, 0.4, 0.45]), np.array([0.6, 0.5, 0.55])]], taxa_aprendizagem=0.5, epocas=2, precisao=1e-7, debug_training=True, plot=False ) # mlp = MultiLayerPerceptron( # neuronios_por_camada=[2,2], # pesos=[[np.zeros(3), np.zeros(3)], # [np.zeros(3), np.zeros(3)]], # taxa_aprendizagem=0.5, desejados=np.array([0.01, 0.99]), # epocas=10, precisao=1e-7, # debug_training=True, plot=False # ) # mlp = MultiLayerPerceptron( # neuronios_por_camada=[2,2], # taxa_aprendizagem=0.5, desejados=np.array([0.01, 0.99]), # epocas=1, precisao=1e-7 # ) mlp.treinar(matriz_entradas=np.array([[0.05, 0.1]]), valores_desejados=np.array([[0.01, 0.99]]))
max_epochs = 500 factory = MLP_Factory() input_train = np.zeros((150, 4)) target_train = np.zeros((150, 1)) factory.generate_sin_values(input_train, target_train) input_test = np.zeros((50, 4)) target_test = np.zeros((50, 1)) factory.generate_sin_values(input_test, target_test) output_train = np.zeros(target_train.shape) output_test = np.zeros(target_test.shape) options = factory.sin_finder(activation_type) nn = MultiLayerPerceptron(options) # Training print("----------------------------------\nTrain\n----------------------------------") for epoch in range(max_epochs): error = 0 for index, value in enumerate(input_train): output_train[index] = nn.forward(value) error += nn.backward(target_train[index]) nn.update_weights(learning_rate[activation_type]) if epoch % 500 == 0: print('Epoch:\t{0}\tError:\t{1}'.format(epoch, error)) learning_rate[activation_type] *= learning_rate_change[activation_type] print('Training:\tAverage difference between target and output: {0}'.format( nn.average_miss(target_train, output_train)[0]))
for loop in range(aveLoop): print "***", loop, "***" # ファイルの作成 # precision preMat = open("./precision/preMat"+str(loop)+".csv", "w") preMat = csv.writer(preMat) # recall recMat = open("./recall/recMat"+str(loop)+".csv", "w") recMat = csv.writer(recMat) # fscore fscMat = open("./F-score/fscMat"+str(loop)+".csv", "w") fscMat = csv.writer(fscMat) # 多層パーセプトロンを構築 mlp = MultiLayerPerceptron(28*28, 1000, 10, act1="sigmoid", act2="softmax", preMat=preMat, recMat=recMat, fscMat=fscMat) ##################### # 0~9の全てのデータ ##################### # 訓練データとテストデータに分解 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) # 教師信号の数字を1-of-K表記に変換(全てのデータ) labels_train = LabelBinarizer().fit_transform(y_train) labels_test = LabelBinarizer().fit_transform(y_test) # 教師信号の数字を1-of-K表記に変換 labels_train = LabelBinarizer().fit_transform(y_train)
#fertility_output_balanced = fertility_df_output.tolist() ## Faz o split dos dados para 70% de treino e 30% de teste training_data, test_data, training_output, test_output = train_test_split( fertility_df_balanced, fertility_output_balanced, test_size=0.3, random_state=42) ## Realiza o treinamento do MLP quantidade_features = training_data.shape[1] mlp = MultiLayerPerceptron(numero_de_entradas=quantidade_features, neuronios_por_camada=[quantidade_features, 1], taxa_aprendizagem=0.5, epocas=1, precisao=0, debug_training=False, plot=False) mlp.treinar(matriz_entradas=training_data, valores_desejados=np.array(training_output)) print("Pesos da rede:") for camada in mlp.camadas: for neuronio in camada.neuronios: print("Camada", camada.indice, ", neurônio", neuronio.indice, ":") print(mlp.pesos[camada.indice][neuronio.indice]) mlp.avaliar(saidas_esperadas=test_output, amostras_de_teste=test_data)
def testConstructor(self): (copyParams, copyInputs) = copy.deepcopy((self.params, self.inputs)) testPercepter = MultiLayerPerceptron(copyParams, copyInputs) expectedParams = list(map(lambda x:x+1, self.params['neuronsByLayer'])) self.assertListEqual(expectedParams, testPercepter.params['neuronsByLayer']) self.assertListEqual(self.biasedInputs, testPercepter.inputs)
[34]: male/???/female (1/0/-1) [35]: education (?) [36]: income (?) """ num_class = 3 feature_dim = 12 num_value = 10 data = np.load('data.npy') neural_data = np.load('NN_data.npy') labels = np.load('labels.npy') #print("Bayes:") #Bayes = NaiveBayes(num_class,feature_dim,num_value) #Bayes.train(data, labels) #guess = Bayes.guess(bayes_features) #Bayes.test(data, labels) #print(guess) #print("Perceptron:") #Perceptron = MultiClassPerceptron(num_class,feature_dim) #Perceptron.train(data, labels) #Perceptron.test(data, labels) #print("Q Agent:") #Reinforcement = Q_Agent(("rock", "paper", "scissors"), 5, 40, 0.7) #Reinforcement.train(data, labels) #Reinforcement.test(data, labels) print("FFNN:") MLP = MultiLayerPerceptron(20, len(neural_data[0])) print("Training..") MLP.train(neural_data, labels, True) print("Testing..") MLP.test(neural_data, labels)
# Then you can just call it like this, which should make thing run faster #train_loader, valid_loader = load_data( "../data/adult_preprocessed.csv", label_name, label_mapping, # preprocess=False, batch_size=opts.batch_size, seed=opts.seed) # based on label_mapping variable, we specify some useful variables in opts if label_mapping is None: # regression opts.classification_type = "regression" opts.total_correct = total_correct_regression opts.output_size = 1 elif len(label_mapping) == 2: # binary opts.classification_type = "binary" opts.total_correct = total_correct_binary opts.output_size = 1 elif len(label_mapping) > 2: # multiclass opts.classification_type = "mulitclass" opts.total_correct = total_correct_multiclass opts.output_size = len(label_mapping) else: ValueError("'label_mapping' needs to have more than 1 attribute") # creating model input_size = len(train_loader.dataset.data[0, :]) model = MultiLayerPerceptron(input_size, num_hidden_layers=opts.num_hidden_layers, hidden_size=opts.hidden_size, actfunction=opts.actfunction, output_size=opts.output_size) # training model final_statistics = train(model, train_loader, valid_loader, opts)