def classify(self, sentence, model_output: tflearn.DNN, user_id="default") -> list: results = model_output.predict([self.bow(sentence, self.words)])[0] results = [[i, r] for i, r in enumerate(results) if r > self.ERROR_THRESHOLD] results.sort(key=lambda x: x[1], reverse=True) return_list = [] for r in results: return_list.append((self.classes[r[0]], r[1])) # array is bad leaning msgError = [] for n in return_list: err = np.array(n[1]) if err < 0.50: msgError.append(err) # return length bad learning is greater than 2 if len(msgError) > 1: msgError.sort(reverse=True) return ['Noel masih belajar nih, bisa diperjelas lagi pertanyaan nya?', 'error', '', msgError[0].tolist()] context = {} for i in self.intents["intents"]: if i["tag"] == return_list[0][0]: context[user_id] = i["context_set"] output_var = [random.choice(i['responses']), i['tag'], context[user_id]] acc = return_list[0][1].tolist() output_var.append(acc) return output_var
def chat(model: tflearn.DNN, data: T.Dict[str, T.Any], words: T.List, labels: T.List) -> None: """ Initialize a discussion with a user and respond to user input with trained model. """ print("Start speaking with me! Enter Q to quit") while True: inp = input("You: ") if inp.lower() == "q" or inp.lower() == "Q": break results = model.predict([bag_of_words(inp, words)]) results_index = numpy.argmax(results) tag = labels[results_index] for tg in data["intents"]: if tg['tag'] == tag: responses = tg['responses'] print(random.choice(responses))
# -*- coding: utf-8 -*- """ Source : https://towardsdatascience.com/tflearn-soving-xor-with-a-2x2x1-feed-forward-neural-network-6c07d88689ed """ from tflearn import DNN from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.estimator import regression #Training examples X = [[0,0], [0,1], [1,0], [1,1]] Y = [[0], [1], [1], [0]] input_layer = input_data(shape=[None, 2]) #input layer of size 2 hidden_layer = fully_connected(input_layer , 2, activation='tanh') #hidden layer of size 2 output_layer = fully_connected(hidden_layer, 1, activation='tanh') #output layer of size 1 #use Stohastic Gradient Descent and Binary Crossentropy as loss function regression = regression(output_layer , optimizer='sgd', loss='binary_crossentropy', learning_rate=5) model = DNN(regression) #fit the model model.fit(X, Y, n_epoch=5000, show_metric=True); #predict all examples print ('Expected: ', [i[0] > 0 for i in Y]) print ('Predicted: ', [i[0] > 0 for i in model.predict(X)]) model.get_weights(hidden_layer.W) model.get_weights(output_layer.W) model.save("tflearn-xor")
testY = trainY[int(0.3 * len(trainY)):] # Training model = DNN(net, clip_gradients=0., tensorboard_verbose=2) embeddingWeights = get_layer_variables_by_name('EmbeddingLayer')[0] # Assign your own weights (for example, a numpy array [input_dim, output_dim]) model.set_weights(embeddingWeights, embeddings) model.fit(trainX, trainY, n_epoch=3, validation_set=0.1, show_metric=True, batch_size=32, shuffle=True) #print( model.evaluate(testX, testY) ) predictions = model.predict(testX) predictions = prob2Onehot(predictions) #print("Predictions : ", list(predictions[10])) ##Calculate F1 Score tp = 0 tn = 0 fp = 0 fn = 0 for i in range(predictions.shape[0]): if list(testY[i]) == [1, 0]: if list(predictions[i]) == [1, 0]: tp += 1 else: fn += 1 else:
class FireDetector: def __init__(self, height=INPUT_HEIGHT, width=INPUT_WIDTH, n_channels=NUMBER_CHANNELS): self.height = height self.width = width self.n_channels = n_channels self.logger = create_logger('Fire Detector') self._build_network() def _build_network(self): self.logger.info('Started CNN structure construction') network = input_data(shape=[None, self.height, self.width, 3], dtype=float32) network = conv_2d(network, 64, 5, strides=4, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = conv_2d(network, 128, 4, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = conv_2d(network, 256, 1, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = fully_connected(network, 4096, activation='tanh') network = dropout(network, 0.5) network = fully_connected(network, 4096, activation='tanh') network = dropout(network, 0.5) network = fully_connected(network, 2, activation='softmax') network = regression(network, optimizer='momentum', loss='categorical_crossentropy', learning_rate=0.001) self.cnn_ = DNN(network, checkpoint_path='firenet', max_checkpoints=1, tensorboard_verbose=2) self.logger.info('Finished CNN structure construction') def load_weights(self, weights_path): self.logger.info('Loading weights...') self.cnn_.load(weights_path, weights_only=True) self.logger.info('Weights loaded successfully') def predict(self, images): images = self._ensure_expected_shape(images) predictions = self.cnn_.predict(images) predictions = [pred[0] for pred in predictions] return predictions def _ensure_expected_shape(self, images): images_reshaped = [] expected_shape = (self.height, self.width, self.n_channels) for img in images: if img.shape != (expected_shape): img = reshape_image(img, self.height, self.width) images_reshaped.append(img) return images_reshaped
def tflearn_OneClass_NN_linear(data_train, data_test, labels_train): X = data_train Y = labels_train D = X.shape[1] No_of_inputNodes = X.shape[1] # Clear all the graph variables created in previous run and start fresh tf.reset_default_graph() # Define the network input_layer = input_data(shape=[None, No_of_inputNodes]) # input layer of size np.random.seed(42) theta0 = np.random.normal(0, 1, K + K * D + 1) * 0.0001 #theta0 = np.random.normal(0, 1, K + K*D + 1) # For linear hidden_layer = fully_connected( input_layer, 4, bias=False, activation='linear', name="hiddenLayer_Weights", weights_init="normal") # hidden layer of size 2 output_layer = fully_connected( hidden_layer, 1, bias=False, activation='linear', name="outputLayer_Weights", weights_init="normal") # output layer of size 1 # Initialize rho value = 0.01 init = tf.constant_initializer(value) rho = va.variable(name='rho', dtype=tf.float32, shape=[], initializer=init) rcomputed = [] auc = [] sess = tf.Session() sess.run(tf.initialize_all_variables()) # print sess.run(tflearn.get_training_mode()) #False tflearn.is_training(True, session=sess) print sess.run(tflearn.get_training_mode()) #now True temp = theta0[-1] oneClassNN_Net = oneClassNN(output_layer, v, rho, hidden_layer, output_layer, optimizer='sgd', loss='OneClassNN_Loss', learning_rate=1) model = DNN(oneClassNN_Net, tensorboard_verbose=3) model.set_weights(output_layer.W, theta0[0:K][:, np.newaxis]) model.set_weights(hidden_layer.W, np.reshape(theta0[K:K + K * D], (D, K))) iterStep = 0 while (iterStep < 100): print "Running Iteration :", iterStep # Call the cost function y_pred = model.predict(data_train) # Apply some ops tflearn.is_training(False, session=sess) y_pred_test = model.predict(data_test) # Apply some ops tflearn.is_training(True, session=sess) value = np.percentile(y_pred, v * 100) tflearn.variables.set_value(rho, value, session=sess) rStar = rho model.fit(X, Y, n_epoch=2, show_metric=True, batch_size=100) iterStep = iterStep + 1 rcomputed.append(rho) temp = tflearn.variables.get_value(rho, session=sess) # print "Rho",temp # print "y_pred",y_pred # print "y_predTest", y_pred_test # g = lambda x: x g = lambda x: 1 / (1 + tf.exp(-x)) def nnScore(X, w, V, g): return tf.matmul(g((tf.matmul(X, w))), V) # Format the datatype to suite the computation of nnscore X = X.astype(np.float32) X_test = data_test X_test = X_test.astype(np.float32) # assign the learnt weights # wStar = hidden_layer.W # VStar = output_layer.W # Get weights values of fc2 wStar = model.get_weights(hidden_layer.W) VStar = model.get_weights(output_layer.W) # print "Hideen",wStar # print VStar train = nnScore(X, wStar, VStar, g) test = nnScore(X_test, wStar, VStar, g) # Access the value inside the train and test for plotting # Create a new session and run the example # sess = tf.Session() # sess.run(tf.initialize_all_variables()) arrayTrain = train.eval(session=sess) arrayTest = test.eval(session=sess) # print "Train Array:",arrayTrain # print "Test Array:",arrayTest # plt.hist(arrayTrain-temp, bins = 25,label='Normal'); # plt.hist(arrayTest-temp, bins = 25, label='Anomalies'); # plt.legend(loc='upper right') # plt.title('r = %1.6f- Sigmoid Activation ' % temp) # plt.show() pos_decisionScore = arrayTrain - temp neg_decisionScore = arrayTest - temp return [pos_decisionScore, neg_decisionScore]
''' # This is the set of possible values to feed to XOR x_train = [[0, 0], [0, 1], [1, 0], [1, 1]] # Given the values fed, this is the expected output y_train = [[0], [1], [1], [0]] # Let's define our DNN. We've got one input layer with a single node, # one hidden layer with two nodes, and one output layer with a single node.. input_layer = input_data(shape=[None, 2]) hidden_layer = fully_connected(input_layer, 2, activation='tanh') output_layer = fully_connected(hidden_layer, 1, activation='tanh') # Let's define our regression activation function for output layer. # we define the optimizing function to be stochastic gradient descent # we define our loss function as binary cross entropy. We define # our learning rate to be 5. regression = regression(output_layer, optimizer='sgd', loss='binary_crossentropy', learning_rate=1) model = DNN(regression) # Now we train the model. model.fit(x_train, y_train, n_epoch=5000, show_metric=True) # Let's see how it worked. print('Expected: ', [i[0] > 0 for i in y_train]) print('Predicted: ', [i[0] > 0 for i in model.predict(x_train)])
from tflearn import DNN from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.estimator import regression ## X = Input data, Y = Output data X = [[0, 0], [0, 1], [1, 0], [1, 1]] Y = [[0], [1], [1], [0]] ## One input layer, one hidden layer and one output layer input_layer = input_data(shape=[None, 2]) hidden_layer = fully_connected(input_layer, 2, activation='tanh') output_layer = fully_connected(hidden_layer, 1, activation='tanh') regression = regression(output_layer, optimizer='sgd', loss='binary_crossentropy', learning_rate=5) model = DNN(regression) model.fit(X, Y, n_epoch=5000, show_metric=True) [i[0] > 0 for i in model.predict(X)] print(model.get_weights(hidden_layer.W), model.get_weights(hidden_layer.b)) print(model.get_weights(output_layer.W), model.get_weights(output_layer.b))
hidden_layer, output_layer, optimizer='sgd', loss='OneClassNN_Loss', learning_rate=1) model = DNN(oneClassNN, tensorboard_verbose=3) model.set_weights(output_layer.W, theta0[0:K][:, np.newaxis]) model.set_weights(hidden_layer.W, np.reshape(theta0[K:K + K * D], (D, K))) iterStep = 0 while (iterStep < 100): print "Running Iteration :", iterStep # Call the cost function y_pred = model.predict(data_train) # Apply some ops tflearn.is_training(False, session=sess) y_pred_test = model.predict(data_test) # Apply some ops tflearn.is_training(True, session=sess) value = np.percentile(y_pred, v * 100) tflearn.variables.set_value(rho, value, session=sess) rStar = rho model.fit(X, Y, n_epoch=2, show_metric=True, batch_size=100) iterStep = iterStep + 1 rcomputed.append(rho) temp = tflearn.variables.get_value(rho, session=sess) # print "Rho",temp # print "y_pred",y_pred # print "y_predTest", y_pred_test
class CowClassifier(object): """ Cow classifier """ def __init__(self): """ default constructor """ # Image self.image_size = 32 # 32x32 # tensorflow network variables self.tf_img_prep = None self.tf_img_aug = None self.tf_network = None self.tf_model = None # 1: setup image preprocessing self.setup_image_preprocessing() # 2: setup neural network self.setup_nn_network() def setup_image_preprocessing(self): """ Setup image preprocessing """ # normalization of images self.tf_img_prep = ImagePreprocessing() self.tf_img_prep.add_featurewise_zero_center() self.tf_img_prep.add_featurewise_stdnorm() # Randomly create extra image data by rotating and flipping images self.tf_img_aug = ImageAugmentation() self.tf_img_aug.add_random_flip_leftright() self.tf_img_aug.add_random_rotation(max_angle=30.) def setup_nn_network(self): """ Setup neural network structure """ # our input is an image of 32 pixels high and wide with 3 channels (RGB) # we will also preprocess and create synthetic images self.tf_network = input_data( shape=[None, self.image_size, self.image_size, 3], data_preprocessing=self.tf_img_prep, data_augmentation=self.tf_img_aug) # layer 1: convolution layer with 32 filters (each being 3x3x3) layer_conv_1 = conv_2d(self.tf_network, 32, 3, activation='relu', name='conv_1') # layer 2: max pooling layer self.tf_network = max_pool_2d(layer_conv_1, 2) # layer 3: convolution layer with 64 filters layer_conv_2 = conv_2d(self.tf_network, 64, 3, activation='relu', name='conv_2') # layer 4: Another convolution layer with 64 filters layer_conv_3 = conv_2d(layer_conv_2, 64, 3, activation='relu', name='conv_3') # layer 5: Max pooling layer self.tf_network = max_pool_2d(layer_conv_3, 2) # layer 6: Fully connected 512 node layer self.tf_network = fully_connected(self.tf_network, 512, activation='relu') # layer 7: Dropout layer (removes neurons randomly to combat overfitting) self.tf_network = dropout(self.tf_network, 0.5) # layer 8: Fully connected layer with two outputs (cow or non cow class) self.tf_network = fully_connected(self.tf_network, 2, activation='softmax') # define how we will be training our network accuracy = Accuracy(name="Accuracy") self.tf_network = regression(self.tf_network, optimizer='adam', loss='categorical_crossentropy', learning_rate=0.0005, metric=accuracy) def load_model(self, model_path): """ Load model """ self.tf_model = DNN(self.tf_network, tensorboard_verbose=0) self.tf_model.load(model_path) def predict_image(self, image_path): """ Predict image """ # Load the image file img = scipy.ndimage.imread(image_path, mode="RGB") # Scale it to 32x32 img = scipy.misc.imresize(img, (32, 32), interp="bicubic").astype(np.float32, casting='unsafe') # Predict return self.tf_model.predict([img])
class Bot: def __init__(self): self.words = [] self.labels = [] self.docs_x = [] self.docs_y = [] self.stemmer = LancasterStemmer() self.data = [] self.training = [] self.output = [] self.out_empty=[] self.model=[] self.count=-1 self.say="" self.Network=Network() def read(self): with open("src/models/intents.json") as f: self.data=load(f) def dump(self): with open("src/models/data.pickle", "wb") as f: dump((self.words, self.labels, self.training, self.output), f) def stem(self): for intent in self.data["intents"]: for pattern in intent["patterns"]: wrds = word_tokenize(pattern) self.words.extend(wrds) self.docs_x.append(wrds) self.docs_y.append(intent["tag"]) if intent["tag"] not in self.labels: self.labels.append(intent["tag"]) self.words = [self.stemmer.stem(w.lower()) for w in self.words if w != "?"] self.words = sorted(list(set(self.words))) self.labels = sorted(self.labels) def modelsetup(self): self.out_empty = [0 for _ in range(len(self.labels))] for x, doc in enumerate(self.docs_x): bag = [] wrds = [self.stemmer.stem(w.lower()) for w in doc] for w in self.words: if w in wrds: bag.append(1) else: bag.append(0) output_row = self.out_empty[:] output_row[self.labels.index(self.docs_y[x])] = 1 self.training.append(bag) self.output.append(output_row) self.training = array(self.training) self.output = array(self.output) self.dump() def setup(self): ops.reset_default_graph() net = input_data(shape=[None, len(self.training[0])]) net = fully_connected(net, 10) net = fully_connected(net, 10) net = fully_connected(net, len(self.output[0]), activation="softmax") net = regression(net) self.model = DNN(net) if exists("src/models/model.tflearn.index"): self.model.load("src/models/model.tflearn") else: self.model.fit(self.training, self.output, n_epoch=1000, batch_size=8, show_metric=True) self.model.save("src/models/model.tflearn") def indexWord(self,x,word): x=x.split(" ") ch="" for i in x: if i.find(word)!=-1: ch=i return ch def bag_of_words(self,s, words): bag = [0 for _ in range(len(words))] translate=[] s_words = word_tokenize(s) s_words = [self.stemmer.stem(word.lower()) for word in s_words] for se in s_words: for i, w in enumerate(words): if w == se: bag[i] = 1 if se not in words and se not in translate: translate.append(se) return array(bag),translate def chat(self,x,ui): try: self.count+=1 predinp,translate=self.bag_of_words(x, self.words) if translate: translate=self.indexWord(str(x),translate[0]) print(translate) results = self.model.predict([predinp]) results_index = argmax(results) tag = self.labels[results_index] except Exception as e: print(e) try: if results[0][results_index] > 0.4: for tg in self.data["intents"]: if tg['tag'] == tag: responses = tg['responses'] self.say=choice(responses) if self.say=="Looking up": self.say=self.Network.Connect(translate.upper()) ui.textEdit.setText(self.say) else: ui.textEdit.setText(self.say) else: self.say="Sorry i can't understand i am still learning try again." ui.textEdit.setText(self.say) except Exception as e: print(e)
output_layer = fully_connected(hidden_layer, 1, activation='tanh') #output layer of size 1 #use Stohastic Gradient Descent and Binary Crossentropy as loss function regression = regression(output_layer, optimizer='sgd', loss='binary_crossentropy', learning_rate=5) model = DNN(regression, tensorboard_verbose=3) #fit the model model.fit(X, Y, n_epoch=5000, show_metric=True) #predict all examples print('Expected: ', [i[0] > 0 for i in Y]) print('Predicted: ', [i[0] > 0 for i in model.predict(X)]) #Did this work ( from Chris ) print("Prints int results ( positive is True, ex 0.99 , False is -0.99 )") for i in model.predict(X): print(i) print("") print("Should be 0") print(model.predict([[0, 0]])) print("") print("Should be 1") print(model.predict([[1, 0]]))
def foo(img_fn, model_fn='../data/model/model_weights'): img = cv2.imread(img_fn, cv2.IMREAD_GRAYSCALE) haar_fn = '../data/haarcascade_russian_plate_number.xml' haar = cv2.CascadeClassifier(haar_fn) detected = haar.detectMultiScale(img) plates = [] for x, y, w, h in detected: obj = img[y:y + h, x:x + w] plates.append(obj) chars = plates[0] < filters.threshold_minimum(plates[0]) labeled_chars, a = ndi.label(chars) labeled_chars = (labeled_chars > 1).astype(np.int8) c = measure.find_contours(labeled_chars, .1) letters = [] for i, v in enumerate(c): xs, ys = zip(*[i for i in v]) x = int(min(xs)) y = int(min(ys)) w = int(max(xs) - x + 2) h = int(max(ys) - y + 2) if w < 15: continue letters.append((y, x, h, w)) letters = sorted(letters) letters_img = [plates[0][x:x + w, y:y + h] for y, x, h, w in letters] letters_img = [i for i in letters_img if i[0, 0] > 127] sizes = [image.size for image in letters_img] median = np.median(sizes) allowed_size = median + median / 4 letters_img = [image for image in letters_img if image.size < allowed_size] size = 64 normalized_img = [] for i in letters_img: ratio = i.shape[0] / i.shape[1] img1 = transform.resize(i, [size, int(size / ratio)], mode='constant') width = img1.shape[1] missing = (size - width) // 2 ones = np.ones([size, missing]) img2 = np.append(ones, img1, 1) img3 = np.append(img2, ones, 1) if 2 * missing + width != size: one = np.ones([size, 1]) img4 = np.append(img3, one, 1) else: img4 = img3 normalized_img.append(img4 * 255) net_input = input_data(shape=[None, 64, 64, 1]) conv1 = conv_2d(net_input, nb_filter=4, filter_size=5, strides=[1, 1, 1, 1], activation='relu') max_pool1 = max_pool_2d(conv1, kernel_size=2) conv2 = conv_2d(max_pool1, nb_filter=8, filter_size=5, strides=[1, 2, 2, 1], activation='relu') max_pool2 = max_pool_2d(conv2, kernel_size=2) conv3 = conv_2d(max_pool2, nb_filter=12, filter_size=4, strides=[1, 1, 1, 1], activation='relu') max_pool3 = max_pool_2d(conv3, kernel_size=2) fc1 = fully_connected(max_pool3, n_units=200, activation='relu') drop1 = dropout(fc1, keep_prob=.5) fc2 = fully_connected(drop1, n_units=36, activation='softmax') net = regression(fc2) model = DNN(network=net) model.load(model_file=model_fn) labels = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') predicted = [] for i in normalized_img: y = model.predict(i.reshape([1, 64, 64, 1])) y_pred = np.argmax(y[0]) predicted.append(labels[y_pred]) return ''.join(predicted)