Esempio n. 1
1
def train(holdout=False, holdout_list=[]):
    # load data
    X, Y = load_X_and_Y()
    x_train, x_dev, x_test = X
    y_train, y_dev, y_test = Y

    # holdout training and dev data if requested
    if holdout:
        X_descr = load_X_descr()
        x_train_all_descr, x_dev_all_descr, _ = X_descr

        holdout_x_train = []
        holdout_y_train = []
        for idx in range(len(x_train)):
            if x_train_all_descr[idx] not in holdout_list:
                holdout_x_train.append(x_train[idx])
                holdout_y_train.append(y_train[idx])

        holdout_x_dev = []
        holdout_y_dev = []
        for idx in range(len(x_dev)):
            if x_dev_all_descr[idx] not in holdout_list:
                holdout_x_dev.append(x_dev[idx])
                holdout_y_dev.append(y_dev[idx])
        
        x_train = np.array(holdout_x_train).reshape((-1, 224, 224, 3))
        y_train = np.array(holdout_y_train).reshape((-1, 1))

        x_dev = np.array(holdout_x_dev).reshape((-1, 224, 224, 3))
        y_dev = np.array(holdout_y_dev).reshape((-1, 1))
    
    # train model
    model = CNN()
    model.fit(x_train, y_train, x_dev, y_dev, save=True)
    model.evaluate(x_test, y_test)
Esempio n. 2
0
def main():
    resize_shape = 64
    print "data is loading..."
    train_X, train_Y, test_X, test_Y = load_data(resize_shape)
    print "data is loaded"
    print "feature engineering..."
    learning_rate = 0.01
    training_iters = 100000
    batch_size = 128
    display_step = 10

    # Network Parameters
    n_input = resize_shape*resize_shape # MNIST data input (img shape: 28*28)
    n_classes = 62 # MNIST total classes (0-9 digits)
    dropout = 0.5 # Dropout, probability to keep units

    with tf.Session() as sess:
        cnn = CNN(sess, learning_rate, training_iters, batch_size, display_step, n_input, n_classes, dropout,resize_shape)
        train_X = cnn.inference(train_X)
        test_X = cnn.inference(test_X)

    print "feature engineering is complete"

    print 'training phase'
    clf = svm.LinearSVC().fit(train_X, train_Y)
    print 'test phase'
    predicts = clf.predict(test_X)

    # measure function
    print 'measure phase'
    print confusion_matrix(test_Y, predicts)
    print f1_score(test_Y, predicts, average=None)
    print precision_score(test_Y, predicts, average=None)
    print recall_score(test_Y, predicts, average=None)
    print accuracy_score(test_Y, predicts)
Esempio n. 3
0
def gridSearch(xTrain, yTrain, xDev, yDev, options):
    paramCombos = myProduct(options)
    bestCombo, bestCrossEntropy = None, float('inf')
    scores = {}
    
    for combo in paramCombos:
        cnn = CNN(numFilters=combo['numFilters'], windowSize=combo['windowSize'])
        cnn.fit(xTrain[:combo['numTrain']], yTrain[:combo['numTrain']], numEpochs=combo['numEpochs'],
                batchSize=combo['batchSize'], verbose=True)
        crossEntropy, accuracy = cnn.evaluate(xDev, yDev, showAccuracy=True)
        scores[tuple(combo.items())] = (crossEntropy, accuracy)
        if crossEntropy < bestCrossEntropy:
            bestCombo, bestCrossEntropy = combo, crossEntropy
        print 'Combo: {}, CE: {}, accuracy: {}'.format(combo, crossEntropy, accuracy)
    return scores
    def __init__(self):

        self.run_recognition = rospy.get_param('/rgb_object_detection/run_recognition')
        self.model_file = rospy.get_param('/rgb_object_detection/model_file')
        self.category_file = rospy.get_param('/rgb_object_detection/category_file')
        self.verbose = rospy.get_param('/rgb_object_detection/verbose')

        self.bridge = CvBridge()
        self.image_sub = rospy.Subscriber('/camera/rgb/image_color', Image, self.img_cb)
        self.patches_sub = rospy.Subscriber('/candidate_regions_depth', PolygonStamped, self.patches_cb)
        self.detection_pub = rospy.Publisher('/detections', Detection)
        # you can read this value off of your sensor from the '/camera/depth_registered/camera_info' topic
        self.P = np.array([[525.0, 0.0, 319.5, 0.0], [0.0, 525.0, 239.5, 0.0], [0.0, 0.0, 1.0, 0.0]])

        if self.run_recognition:
            self.cnn = CNN(self.model_file, self.category_file, self.verbose)
Esempio n. 5
0
# -*- coding: utf-8 -*-

from cnn import CNN
import pandas as pd


cnn = CNN()
data=pd.DataFrame()

data['cnn_feature']=0
data['cnn_feature']=data['cnn_feature'].astype(object)

featurelist = cnn.get_features(['/home/seonhoon/Desktop/workspace/ImageQA/version_tensorflow/web/images/moodo.jpg'], layer='fc7')
data.loc[0,'cnn_feature']=featurelist[0].flatten()


data.to_pickle('/home/seonhoon/Desktop/workspace/ImageQA/version_tensorflow/web/cnn.pkl')
def main():
    for k, v in a._get_kwargs():
        print(k, "=", v)

    with open(os.path.join(a.output_dir, "options.json"), "w") as f:
        f.write(json.dumps(vars(a), sort_keys=True, indent=4))

    loader = Loader(a.batch_size)

    # initialize models here
    model = CNN(a)

    if a.checkpoint is not None:
        print("loading model from checkpoint")
        model.load(a.checkpoint)

    if a.mode == 'test':
        if a.checkpoint is None:
            print('need checkpoint to continue')
            return
        draw(model, os.path.join(a.output_dir, 'test_output.jpg'))
    else:
        # training
        start = time.time()
        for epoch in range(a.max_epochs):

            def should(freq):
                return freq > 0 and ((epoch + 1) % freq == 0
                                     or epoch == a.max_epochs - 1)

            training_loss = 0

            for _ in range(loader.ntrain):
                X, y = loader.next_batch(0)
                model.step(X, y)
                training_loss += model.loss.data[0]

            training_loss /= loader.ntrain

            if should(a.validation_freq):
                print('validating model')
                validation_loss = 0
                for _ in range(loader.nval):
                    X, y = loader.next_batch(1)
                    model.validate_step(X, y)
                    validation_loss += model.loss.data[0]
                validation_loss /= loader.nval

            if should(a.summary_freq):
                print("recording summary")
                with open(os.path.join(a.output_dir, 'loss_record.txt'),
                          "a") as loss_file:
                    loss_file.write("%s\t%s\t%s\n" %
                                    (epoch, training_loss, validation_loss))

            if should(a.progress_freq):
                rate = (epoch + 1) / (time.time() - start)
                remaining = (a.max_epochs - 1 - epoch) / rate
                print("progress  epoch %d  remaining %dh" %
                      (epoch, remaining / 3600))
                print("training loss", training_loss)

            if should(a.display_freq):
                draw(model, os.path.join(a.output_dir, '%s.jpg' % epoch))

            if should(a.save_freq):
                print("saving model")
                model.save(os.path.join(a.output_dir, '%s.pth' % epoch))
Esempio n. 7
0
    accuracy = 100 * correct / total

    print('Test Accuracy of the model on the %d test images: %d %%' %
          (total, accuracy))

    return accuracy


# Hyper Parameters
num_epochs = 100
batch_size = 100
learning_rate = 1e-5
wt_decay = 1e-7
lr_decay = 0.99

cnn = CNN()

print("Fetching data...")

train_dataset = get_augmented_dataset("./tiny-imagenet-200/train")
test_dataset = get_dataset("./tiny-imagenet-200/val")

train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)

# Loss and Optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(cnn.parameters(),
                             lr=learning_rate,
Esempio n. 8
0
import paddle.fluid as fluid
from PIL import Image
import numpy as np
from cnn import CNN

# 使用动态图with块,指定使用GPU或者CPU预测
with fluid.dygraph.guard(place=fluid.CPUPlace()):
    # 获取网络结构
    cnn_infer = CNN("mnist")
    # 加载模型参数
    param_dict, _ = fluid.dygraph.load_dygraph("models/cnn")
    # 把参数加载到网络中
    cnn_infer.load_dict(param_dict)
    # 开始执行预测
    cnn_infer.eval()

    # 预处理数据
    def load_image(file):
        im = Image.open(file).convert('L')
        im = im.resize((28, 28), Image.ANTIALIAS)
        im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
        im = im / 255.0 * 2.0 - 1.0
        return im

    # 获取预测数据
    tensor_img = load_image('image/infer_3.png')
    # 执行预测
    results = cnn_infer(fluid.dygraph.base.to_variable(tensor_img))
    # 安装概率从大到小排序标签
    lab = np.argsort(-results.numpy())
    print("infer_3.png 预测的结果为: %d" % lab[0][0])
        Y = binarizer.fit_transform(y)

        hidden_layer_sizes = [50]
        model = NeuralNet(hidden_layer_sizes)

        model.fit(X, Y)

        y_pred2 = model.predict(Xtest)
        v_error2 = np.mean(y_pred2 != ytest)

        print(v_error2)

    # CNN
    elif question == "1.5":

        with open(os.path.join('..', 'data', 'mnist.pkl'), 'rb') as f:
            train_set, valid_set, test_set = pickle.load(f, encoding="latin1")

        X, y = train_set
        Xtest, ytest = test_set

        model = CNN()
        model.fit(X, y)

        y_pred2 = model.predict(Xtest)
        v_error2 = np.mean(y_pred2 != ytest)

        print(v_error2)

    else:
        print("Unknown question: %s" % question)
class RGBObjectDetection:

    def __init__(self):

        self.run_recognition = rospy.get_param('/rgb_object_detection/run_recognition')
        self.model_file = rospy.get_param('/rgb_object_detection/model_file')
        self.category_file = rospy.get_param('/rgb_object_detection/category_file')
        self.verbose = rospy.get_param('/rgb_object_detection/verbose')

        self.bridge = CvBridge()
        self.image_sub = rospy.Subscriber('/camera/rgb/image_color', Image, self.img_cb)
        self.patches_sub = rospy.Subscriber('/candidate_regions_depth', PolygonStamped, self.patches_cb)
        self.detection_pub = rospy.Publisher('/detections', Detection)
        # you can read this value off of your sensor from the '/camera/depth_registered/camera_info' topic
        self.P = np.array([[525.0, 0.0, 319.5, 0.0], [0.0, 525.0, 239.5, 0.0], [0.0, 0.0, 1.0, 0.0]])

        if self.run_recognition:
            self.cnn = CNN(self.model_file, self.category_file, self.verbose)

    def img_cb(self, msg):
        try:
          self.cv_image = self.bridge.imgmsg_to_cv2(msg, "bgr8")
        except CvBridgeError as e:
          print(e)

    def patches_cb(self, msg):
        if hasattr(self, 'cv_image'):
            ul_pc = msg.polygon.points[0]
            lr_pc = msg.polygon.points[1]
            cen_pc = msg.polygon.points[2]

            p1_pc = np.array([[ul_pc.x], [ul_pc.y], [ul_pc.z], [1.0]])
            p2_pc = np.array([[lr_pc.x], [lr_pc.y], [lr_pc.z], [1.0]])

            # transform from xyz (depth) space to xy (rgb) space, http://docs.ros.org/api/sensor_msgs/html/msg/CameraInfo.html
            p1_im = np.dot(self.P,p1_pc)
            p1_im = p1_im/p1_im[2] #scaling
            p2_im = np.dot(self.P,p2_pc)
            p2_im = p2_im/p2_im[2] #scaling

            p1_im_x = int(p1_im[0])
            p1_im_y = int(p1_im[1])
            p2_im_x = int(p2_im[0])
            p2_im_y = int(p2_im[1])

            # x is positive going right, y is positive going down
            width = p2_im_x - p1_im_x
            height = p1_im_y - p2_im_y

            # expand in y direction to account for angle of sensor
            expand_height = 0.4 # TODO: fix hack with transform/trig
            height_add = height * expand_height
            p1_im_y = p1_im_y + int(height_add)
            height = p1_im_y - p2_im_y

            # fix bounding box to be square
            diff = ( abs(width - height) / 2.0)
            if width > height: # update ys
                p1_im_y = int(p1_im_y + diff)
                p2_im_y = int(p2_im_y - diff)
            elif height > width: # update xs
                p1_im_x = int(p1_im_x - diff)
                p2_im_x = int(p2_im_x + diff)

            ## expand total box to create border around object (e.g. expand box 40%)
            expand_box = 0.4
            box_add = (width * expand_box)/2.0
            p1_im_x = int(p1_im_x - box_add)
            p1_im_y = int(p1_im_y + box_add)
            p2_im_x = int(p2_im_x + box_add)
            p2_im_y = int(p2_im_y - box_add)

            #plot expanded bounding box in green
            cv2.rectangle(self.cv_image, (p1_im_x, p1_im_y), (p2_im_x, p2_im_y), (0, 255, 0), thickness=5)

            # optional : run the recognition portion of the pipeline
            self.pred = ''
            self.pred_val = 0.0
            if self.run_recognition:
                # crop image based on rectangle, note: its img[y: y + h, x: x + w] and *not* img[x: x + w, y: y + h]
                self.crop_img = self.cv_image[p2_im_y:p1_im_y, p1_im_x:p2_im_x]
                im = PImage.fromarray(self.crop_img, 'RGB')
                im = im.resize((self.cnn.sample_size, self.cnn.sample_size)) # resize
                im_gray = im.convert('L') # luma transform -  L = R * 299/1000 + G * 587/1000 + B * 114/1000
                im_gray_list = list(im_gray.getdata()) # make it into normal readable object
                im_gray_list_np = np.array(im_gray_list) / 255.0
                im_pred = im_gray_list_np.reshape((1,1,self.cnn.sample_size,self.cnn.sample_size))
                pred = self.cnn.predict(im_pred)
                self.pred = self.cnn.inv_catagories[np.argmax(pred,1)[0]]
                self.pred_val = np.max(pred,1)[0]
                font = cv2.FONT_HERSHEY_SIMPLEX
                label_text = str(self.pred)
                font_size = 1.0
                font_thickness = 2
                cv2.putText(self.cv_image, label_text, (p1_im_x,p1_im_y), font, font_size,(255,255,255), font_thickness)

            # publish detection message
            det_msg = Detection()
            det_msg.obj_class = self.pred
            det_msg.point = cen_pc
            self.detection_pub.publish(det_msg)

            # show image window
            cv2.imshow("Image window", self.cv_image)
            cv2.waitKey(3)
Esempio n. 11
0
def keyword_search():

    start = time()
    # web browser
    options = webdriver.ChromeOptions()
    options.add_argument('--ignore-certificate-errors')
    options.add_argument('--incognito')
    prefs = {
        "profile.managed_default_content_settings.images": 2,
        "profile.default_content_settings.images": 2,
        "disk-cache-size": 4096
    }
    options.add_experimental_option("prefs", prefs)
    options.add_argument('--headless')
    driver = webdriver.Chrome(chrome_options=options)
    print(f'Browser creation took {(time() - start):.4f}s:')

    # setup args for site and keyword
    # get site to use, if none use all
    src = request.args.get('source')
    src = src.lower() if src is not None else src
    keyword = request.args.get('key')
    # make args for only some links

    sites = []
    # select th sites to use
    if src is None:
        sites.append(CNN(driver))
        sites.append(HuffPost(driver))
        sites.append(WashPost(driver))
        sites.append(Fox(driver))
        sites.append(WSJ(driver))
        sites.append(CBS(driver))
        sites.append(WashTimes(driver))
        sites.append(BiReport(driver))
        sites.append(InfoWars(driver))
        sites.append(NYT(driver))
        sites.append(NBC(driver))
        sites.append(CNS(driver))
    elif src == "cnn":
        sites.append(CNN(driver))
    elif src == "huffpost":
        sites.append(HuffPost(driver))
    elif src == "washpost":
        sites.append(WashPost(driver))
    elif src == "fox":
        sites.append(Fox(driver))
    elif src == "wsj":
        sites.append(WSJ(driver))
    elif src == "cbs":
        sites.append(CBS(driver))
    elif src == "washtimes":
        sites.append(WashTimes(driver))
    elif src == "bireport":
        sites.append(BiReport(driver))
    elif src == "infowars":
        sites.append(InfoWars(driver))
    elif src == "nyt":
        sites.append(NYT(driver))
    elif src == "nbc":
        sites.append(NBC(driver))
    elif src == "cns":
        sites.append(CNS(driver))

    data = {'data': []}
    for site in sites:
        site_time = time()
        # get the links and its source
        links = site.get_links(keyword)
        link_src = site.__class__.__name__
        for link in links:

            #edit title
            title = link[1]
            title = title.replace('\u2019', '\'')
            title = title.replace('\u2018', '\'')
            title = title.replace('\u201c', '"')
            title = title.replace('\u201d', '"')
            title = title.replace('\u2013', '-')
            title = title.replace('\u2014', '-')

            new_entry = {
                'src': link_src,
                'link': link[0],
                'title': title,
                'bias': site.bias_score
            }
            data['data'].append(new_entry)

        print(f'Reading "{link_src}" took {(time() - site_time):.4f}s')

    random.shuffle(data['data'])

    #json_str = json.dumps(data)
    response = jsonify(data)
    response.headers.add('Access-Control-Allow-Origin', '*')

    driver.quit()

    print(f'Total time for request took {(time() - start):.4f}s:')

    return response
Esempio n. 12
0
def test_predict():
    X = np.float32([[0.1, 0.2, 0.3, 0.4, 0.5, -0.1, -0.2, -0.3, -0.4, -0.5]])
    X = np.float32([[0.1, 0.2, 0.3, 0.4, 0.5, 0, 0, 0, 0, 0]])
    X = np.float32([np.linspace(0, 10, num=10)])
    my_cnn = CNN()
    my_cnn.add_input_layer(shape=(10, ), name="input0")
    my_cnn.append_dense_layer(num_nodes=5, activation='linear', name="layer1")
    w = my_cnn.get_weights_without_biases(layer_name="layer1")
    w_set = np.full_like(w, 2)
    my_cnn.set_weights_without_biases(w_set, layer_name="layer1")
    b = my_cnn.get_biases(layer_name="layer1")
    b_set = np.full_like(b, 2)
    b_set[0] = b_set[0] * 2
    my_cnn.set_biases(b_set, layer_name="layer1")
    actual = my_cnn.predict(X)
    assert np.array_equal(actual, np.array([[104., 102., 102., 102., 102.]]))
Esempio n. 13
0
def test_remove_last_layer():
    from tensorflow.keras.datasets import cifar10
    batch_size = 32
    num_classes = 10
    epochs = 100
    data_augmentation = True
    num_predictions = 20
    save_dir = os.path.join(os.getcwd(), 'saved_models')
    model_name = 'keras_cifar10_trained_model.h5'
    (X_train, y_train), (X_test, y_test) = cifar10.load_data()
    number_of_train_samples_to_use = 100
    X_train = X_train[0:number_of_train_samples_to_use, :]
    y_train = y_train[0:number_of_train_samples_to_use]
    my_cnn = CNN()
    my_cnn.add_input_layer(shape=(32, 32, 3), name="input")
    my_cnn.append_conv2d_layer(num_of_filters=16,
                               kernel_size=(3, 3),
                               padding="same",
                               activation='linear',
                               name="conv1")
    my_cnn.append_maxpooling2d_layer(pool_size=2,
                                     padding="same",
                                     strides=2,
                                     name="pool1")
    my_cnn.append_conv2d_layer(num_of_filters=8,
                               kernel_size=3,
                               activation='relu',
                               name="conv2")
    my_cnn.append_flatten_layer(name="flat1")
    my_cnn.append_dense_layer(num_nodes=10, activation="relu", name="dense1")
    my_cnn.append_dense_layer(num_nodes=2, activation="relu", name="dense2")
    out = my_cnn.predict(X_train)
    assert out.shape == (number_of_train_samples_to_use, 2)
    my_cnn.remove_last_layer()
    out = my_cnn.predict(X_train)
    assert out.shape == (number_of_train_samples_to_use, 10)
Esempio n. 14
0
def test_set_weights_without_biases():
    my_cnn = CNN()
    image_size = (np.random.randint(32, 100), np.random.randint(20, 100),
                  np.random.randint(3, 10))
    number_of_conv_layers = np.random.randint(2, 10)
    my_cnn.add_input_layer(shape=image_size, name="input")
    previous_depth = image_size[2]
    for k in range(number_of_conv_layers):
        number_of_filters = np.random.randint(3, 100)
        kernel_size = np.random.randint(3, 9)
        my_cnn.append_conv2d_layer(num_of_filters=number_of_filters,
                                   kernel_size=(kernel_size, kernel_size),
                                   padding="same",
                                   activation='linear')

        w = my_cnn.get_weights_without_biases(layer_number=k + 1)
        w_set = np.full_like(w, 0.2)
        my_cnn.set_weights_without_biases(w_set, layer_number=k + 1)
        w_get = my_cnn.get_weights_without_biases(layer_number=k + 1)
        assert w_get.shape == w_set.shape
        previous_depth = number_of_filters
    pool_size = np.random.randint(2, 5)
    my_cnn.append_maxpooling2d_layer(pool_size=pool_size,
                                     padding="same",
                                     strides=2,
                                     name="pool1")
    my_cnn.append_flatten_layer(name="flat1")
    my_cnn.append_dense_layer(num_nodes=10)
    number_of_dense_layers = np.random.randint(2, 10)
    previous_nodes = 10
    for k in range(number_of_dense_layers):
        number_of_nodes = np.random.randint(3, 100)
        kernel_size = np.random.randint(3, 9)
        my_cnn.append_dense_layer(num_nodes=number_of_nodes)

        w = my_cnn.get_weights_without_biases(layer_number=k +
                                              number_of_conv_layers + 4)
        w_set = np.full_like(w, 0.8)
        my_cnn.set_weights_without_biases(w_set,
                                          layer_number=k +
                                          number_of_conv_layers + 4)
        w_get = my_cnn.get_weights_without_biases(layer_number=k +
                                                  number_of_conv_layers + 4)
        assert w_get.shape == w_set.shape
        previous_nodes = number_of_nodes
Esempio n. 15
0
def test_load_and_save_model():
    # Note: This test may take a long time to load the data
    my_cnn = CNN()
    my_cnn.load_a_model(model_name="VGG19")
    w = my_cnn.get_weights_without_biases(layer_name="block5_conv4")
    assert w.shape == (3, 3, 512, 512)
    w = my_cnn.get_weights_without_biases(layer_number=-1)
    assert w.shape == (4096, 1000)
    my_cnn.append_dense_layer(num_nodes=10)
    path = os.getcwd()
    file_path = os.path.join(path, "my_model.h5")
    my_cnn.save_model(model_file_name=file_path)
    my_cnn.load_a_model(model_name="VGG16")
    w = my_cnn.get_weights_without_biases(layer_name="block4_conv1")
    assert w.shape == (3, 3, 256, 512)
    my_cnn.load_a_model(model_file_name=file_path)
    os.remove(file_path)
    w = my_cnn.get_weights_without_biases(layer_number=-1)
    assert w.shape == (1000, 10)
Esempio n. 16
0
def train(x_train, y_train, vocab_processor, x_dev, y_dev):
    config = get_tfconfig()
    with tf.Graph().as_default():
        with tf.Session(config=config) as sess:
            with sess.as_default():
                cnn = CNN(x_train.shape[1], y_train.shape[1],
                          len(vocab_processor.vocabulary_), EMBEDDING_DIM,
                          list(map(int, FILTER_SIZES.split(","))), NUM_FILTERS,
                          L2_REG_LAMBDA)
                gstep = tf.Variable(0, name="gstep", trainable=False)
                optimizer = tf.train.AdamOptimizer(learning_rate=0.001)
                grads_vars = optimizer.compute_gradients(cnn.loss)
                train_op = optimizer.apply_gradients(grads_vars,
                                                     global_step=gstep)
                # output dictionary for models
                time_stamp = str(int(time.time()))
                out_dir = os.path.abspath(
                    os.path.join(os.path.curdir, "runs", time_stamp))
                print("writing to {}".format(out_dir))
                # gradients summaries
                grad_summaries = []
                accuracy_list = []
                for g, v in grads_vars:
                    if g is not None:
                        grad_hist_summary = tf.summary.histogram(
                            "{}/grad/hist".format(v.name), g)
                        grad_summaries.append(grad_hist_summary)
                        ## sparsity - 얘는 뭐하는 친구였을까요?
                        sparsity_summary = tf.summary.scalar(
                            "{}/grad/sparsity".format(v.name),
                            tf.nn.zero_fraction(g))
                        grad_summaries.append(sparsity_summary)
                grad_summaries_merged = tf.summary.merge(grad_summaries)
                ##
                loss_summary = tf.summary.scalar("loss", cnn.loss)
                acc_summary = tf.summary.scalar("accuracy", cnn.accuracy)
                ##
                train_summary_op = tf.summary.merge(
                    [loss_summary, acc_summary, grad_summaries_merged])
                train_summary_dir = os.path.join(out_dir, "summaries", "train")
                train_summary_writer = tf.summary.FileWriter(
                    train_summary_dir, sess.graph)
                dev_summary_op = tf.summary.merge([loss_summary, acc_summary])
                dev_summary_dir = os.path.join(out_dir, "summaries", "dev")
                dev_summary_writer = tf.summary.FileWriter(
                    dev_summary_dir, sess.graph)
                ##
                checkpoint_dir = os.path.abspath(
                    os.path.join(out_dir, "checkpoints"))
                checkpoint_prefix = os.path.join(checkpoint_dir, "model")
                if not os.path.exists(checkpoint_dir):
                    os.makedirs(checkpoint_dir)
                saver = tf.train.Saver(tf.global_variables(),
                                       max_to_keep=NUM_CHECKPOINTS)
                vocab_processor.save(os.path.join(out_dir, "vocab"))
                sess.run(tf.global_variables_initializer())

                def train_step(x_bat, y_bat):
                    feed_dict = {
                        cnn.x: x_bat,
                        cnn.y: y_bat,
                        cnn.keep_prob: KEEP_PROB
                    }
                    _, step, summaries, loss, acc = sess.run([
                        train_op, gstep, train_summary_op, cnn.loss,
                        cnn.accuracy
                    ], feed_dict)
                    time_str = datetime.datetime.now().isoformat()
                    print("{}: step {}. loss {}, acc {}".format(
                        time_str, step, loss, acc))
                    train_summary_writer.add_summary(summaries, step)

                def dev_step(x_bat, y_bat, writer=None):
                    feed_dict = {
                        cnn.x: x_bat,
                        cnn.y: y_bat,
                        cnn.keep_prob: 1.0
                    }
                    step, summaries, loss, acc = sess.run(
                        [gstep, dev_summary_op, cnn.loss, cnn.accuracy],
                        feed_dict)
                    time_str = datetime.datetime.now().isoformat()
                    print("{}: step {}. loss {}, acc {}".format(
                        time_str, step, loss, acc))
                    ##
                    max_acc = max(
                        accuracy_list) if len(accuracy_list) > 2 else -1000
                    if max_acc < acc:
                        print("update {} -> {}, length {}".format(
                            max_acc, acc, len(accuracy_list)))
                        accuracy_list.append(acc)
                    if writer:
                        writer.add_summary(summaries, step)

                data = list(zip(x_train, y_train))
                batches = batch_iter(data, BATCH_SIZE, NUM_EPOCHS)
                for batch in batches:
                    x_bat, y_bat = zip(*batch)
                    train_step(x_bat, y_bat)
                    cur_step = tf.train.global_step(sess, gstep)
                    if cur_step % EVAL_EVERY == 0:
                        print("\nEvaluation : ")
                        dev_step(x_dev, y_dev, writer=dev_summary_writer)
                        print("")
                    if cur_step % CHECKPOINT_EVERY == 0:
                        path = saver.save(sess,
                                          checkpoint_prefix,
                                          global_step=cur_step)
                        print("Saved model checkpoint to {}\n".format(path))
                    if len(accuracy_list) > 6:
                        max_acc = max(accuracy_list)
                        mm = 5
                        for idx, iacc in enumerate(accuracy_list[-5:]):
                            if max_acc > iacc: mm -= 1
                        if mm == 0:
                            break
Esempio n. 17
0
def main():
    # Training settings
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
    parser.add_argument('--batch-size',
                        type=int,
                        default=64,
                        metavar='N',
                        help='input batch size for training (default: 64)')
    parser.add_argument('--test-batch-size',
                        type=int,
                        default=1000,
                        metavar='N',
                        help='input batch size for testing (default: 1000)')
    parser.add_argument('--epochs',
                        type=int,
                        default=10,
                        metavar='N',
                        help='number of epochs to train (default: 10)')
    parser.add_argument('--lr',
                        type=float,
                        default=0.01,
                        metavar='LR',
                        help='learning rate (default: 0.01)')
    parser.add_argument('--momentum',
                        type=float,
                        default=0.5,
                        metavar='M',
                        help='SGD momentum (default: 0.5)')
    parser.add_argument('--no-cuda',
                        action='store_true',
                        default=False,
                        help='disables CUDA training')
    parser.add_argument('--seed',
                        type=int,
                        default=1,
                        metavar='S',
                        help='random seed (default: 1)')
    parser.add_argument(
        '--log-interval',
        type=int,
        default=10,
        metavar='N',
        help='how many batches to wait before logging training status')
    parser.add_argument('--optimizer', type=str, default='sgd',
                        help='which optimizer to use in training. Valid options are' + \
                            '\'sgd\' or \'kfac\'.')
    parser.add_argument('--save-model',
                        action='store_true',
                        default=False,
                        help='For Saving the current Model')
    parser.add_argument(
        '--save-stats',
        type=str,
        default=None,
        help='name of file to save training loss and test loss and accuracy.')
    parser.add_argument('--test-every',
                        type=int,
                        default=None,
                        help='test the model roughly every n examples')
    args = parser.parse_args()
    use_cuda = not args.no_cuda and torch.cuda.is_available()

    torch.manual_seed(args.seed)

    device = torch.device("cuda" if use_cuda else "cpu")

    kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
    train_loader = torch.utils.data.DataLoader(datasets.MNIST(
        '.',
        train=True,
        download=True,
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307, ), (0.3081, ))
        ])),
                                               batch_size=args.batch_size,
                                               shuffle=True,
                                               **kwargs)
    test_loader = torch.utils.data.DataLoader(datasets.MNIST(
        '.',
        train=False,
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307, ), (0.3081, ))
        ])),
                                              batch_size=args.test_batch_size,
                                              shuffle=True,
                                              **kwargs)

    model = CNN().to(device)
    if args.optimizer == 'sgd':
        optimizer = optim.SGD(model.parameters(),
                              lr=args.lr,
                              momentum=args.momentum)
    elif args.optimizer == 'kfac':
        optimizer = KFAC(model, F.nll_loss)

    train_stats = {}
    for epoch in range(1, args.epochs + 1):
        train(args, model, device, train_loader, test_loader, optimizer, epoch,
              train_stats)
        test(args, model, device, test_loader)

    if (args.save_model):
        torch.save(model.state_dict(), "mnist_cnn.pt")
Esempio n. 18
0
currValLoss = 1e6

totalIter = cfg.TRAIN_NB / cfg.BatchSize

LogFile = codecs.open(cfg.LogFile, "a")

phase_train = tf.Variable(True, name='phase_train')

x = tf.placeholder(tf.float32, shape=[None, WND_HEIGHT, WND_WIDTH])

SeqLens = tf.placeholder(shape=[cfg.BatchSize], dtype=tf.int32)

x_expanded = tf.expand_dims(x, 3)

#Inputs = CNNLight(x_expanded, phase_train, 'CNN_1')
Inputs = CNN(x_expanded, phase_train, 'CNN_1')

logits = RNN(Inputs, SeqLens, 'RNN_1')

# Target params
indices = tf.placeholder(dtype=tf.int64, shape=[None, 2])
values = tf.placeholder(dtype=tf.int32, shape=[None])
shape = tf.placeholder(dtype=tf.int64, shape=[2])

# Make targets
targets = tf.SparseTensor(indices, values, shape)

# Compute Loss
losses = tf.nn.ctc_loss(targets, logits, SeqLens)

loss = tf.reduce_mean(losses)
Esempio n. 19
0
    train_set = numpy.transpose(data_set[0], (2, 0, 1))
    # train_set = numpy.transpose(data_set, (2, 0, 1))

    # cnn2_output = load_RGB('data/kosode/cnn2_after_train_norm', file_num * motif_num)

    # cnn1_W = loadW('data/kosode_motif2/train/cnn1_after_train')
    # cnn2_W = loadW('data/kosode_motif2/train/cnn2_after_train')

    makeFolder()

    # 時間計測
    time1 = time.clock()

    print '~~~CNN1~~~'

    cnn1 = CNN(train_set, filter_shape, filter_shift_list[0], input_shape, node_shape[1], cnn_pre_train_lr, cnn_pre_train_epoch, isRGB)

    output_list = cnn1.output()
    cnn_saveColorImage(output_list, node_shape[1], 'cnn1_before_train')
    output_list_norm = local_contrast_normalization(output_list)
    cnn_saveColorImage(output_list_norm, node_shape[1], 'cnn1_before_training_norm')

    cnn1.pre_train()
    # cnn1.setW(cnn1_W)

    output_list = cnn1.output()
    cnn_saveColorImage(output_list, node_shape[1], 'cnn1_after_train')
    output_list_norm = local_contrast_normalization(output_list)
    cnn_saveColorImage(output_list_norm, node_shape[1], 'cnn1_after_train_norm')

    print '~~~CNN2~~~'
Esempio n. 20
0
def test_add_input_layer():
    model = CNN()
    out = model.add_input_layer(shape=(256, 256, 3), name="input0")
    assert True
Esempio n. 21
0
def makeprediction(config_file, data_file=None, out_path=None, out_file=None, gpu=None):
    
    #Open configuration file for this network
    config = ConfigParser.ConfigParser()
    config.read(config_file)
    
    #Set the device on which to perform these computations
    if gpu:
        theano.sandbox.cuda.use(gpu)
        theano.config.nvcc.flags='-use=fast=math'
        theano.config.allow_gc=False
    else:
        device = config.get('General', 'device')
        theano.sandbox.cuda.use(device)
        if (device != 'cpu'):
            theano.config.nvcc.flags='-use=fast=math'
            theano.config.allow_gc=False
    #------------------------------------------------------------------------------

    starttime=time.clock()
    print '\nInitializing Network'
    if os.path.exists(config.get('General', 'directory')+config.get('Network', 'weights_folder')):
        network = CNN(weights_folder = config.get('General', 'directory')+config.get('Network', 'weights_folder'),
                      activation = config.get('Network', 'activation'))
    else:
        print 'Error: Weights folder does not exist. Could not initialize network'
        return;
    #------------------------------------------------------------------------------
    
    print 'Opening Data Files'
    if data_file:
        test_data = LoadData(directory = '', data_file_name = data_file)
    else:
        test_data = LoadData(directory = config.get('Testing Data', 'folders').split(','), 
                             data_file_name = config.get('Testing Data', 'data_file'))
    #------------------------------------------------------------------------------
    init_time = time.clock() - starttime
    print "Initialization = " + `init_time` + " seconds"       
                           
            
    starttime = time.clock()                 
    print 'Making Predictions'
    if out_path and out_file:
        network.predict(test_data.get_data(),
                        results_folder = out_path,
                        name = out_file)
    elif out_path:
        network.predict(test_data.get_data(),
                        results_folder = out_path,
                        name = config.get('Testing', 'prediction_file'))
    elif out_file:
        network.predict(test_data.get_data(),
                        results_folder = config.get('General', 'directory')+config.get('Testing', 'prediction_folder'),
                        name = out_file)
    else:
        network.predict(test_data.get_data(),
                        results_folder = config.get('General', 'directory')+config.get('Testing', 'prediction_folder'),
                        name = config.get('Testing', 'prediction_file'))
    pred_time = time.clock() - starttime
    #------------------------------------------------------------------------------
    print "Prediction Time   = " + `pred_time` + " seconds"
        
    test_data.close()
Esempio n. 22
0
def test_get_weights_without_biases_3():
    my_cnn = CNN()
    image_size = (np.random.randint(32, 100), np.random.randint(20, 100),
                  np.random.randint(3, 10))
    number_of_conv_layers = np.random.randint(2, 10)
    my_cnn.add_input_layer(shape=image_size, name="input")
    previous_depth = image_size[2]
    for k in range(number_of_conv_layers):
        number_of_filters = np.random.randint(3, 100)
        kernel_size = np.random.randint(3, 9)
        my_cnn.append_conv2d_layer(num_of_filters=number_of_filters,
                                   kernel_size=(kernel_size, kernel_size),
                                   padding="same",
                                   activation='linear')

        actual = my_cnn.get_weights_without_biases(layer_number=k + 1)
        assert actual.shape == (kernel_size, kernel_size, previous_depth,
                                number_of_filters)
        previous_depth = number_of_filters
    actual = my_cnn.get_weights_without_biases(layer_number=0)
    assert actual is None
    pool_size = np.random.randint(2, 5)
    my_cnn.append_maxpooling2d_layer(pool_size=pool_size,
                                     padding="same",
                                     strides=2,
                                     name="pool1")
    actual = my_cnn.get_weights_without_biases(layer_name="pool1")
    assert actual is None
    my_cnn.append_flatten_layer(name="flat1")
    actual = my_cnn.get_weights_without_biases(layer_name="flat1")
    assert actual is None
    my_cnn.append_dense_layer(num_nodes=10)
    number_of_dense_layers = np.random.randint(2, 10)
    previous_nodes = 10
    for k in range(number_of_dense_layers):
        number_of_nodes = np.random.randint(3, 100)
        kernel_size = np.random.randint(3, 9)
        my_cnn.append_dense_layer(num_nodes=number_of_nodes)
        actual = my_cnn.get_weights_without_biases(layer_number=k +
                                                   number_of_conv_layers + 4)
        previous_nodes = number_of_nodes
Esempio n. 23
0
def main():
    # VARIABLES - FILES
    # NOTE: Make sure to change these for different libraries!
    phone_file = conf.get_string("phone_file")  # path to file of phone list
    dictionary_file = conf.get_string(
        "dictionary_file")  # path to file of word list
    transcript_file = conf.get_string(
        "transcript_file")  # path/directory of transcript file(s)
    transcript_type = conf.get_string(
        "transcript_type"
    )  # library being used (to find & parse transcript file)
    words_to_phones_file = conf.get_string(
        "words_to_phones_file")  # path to file matching words with phones
    directory_path = conf.get_string(
        "directory_path")  # directory containing audio files

    # VARIABLES - NUMBERS
    learning_rate = .2
    epoch = 1
    #   Layer 1:
    filter_width = 2  # width of convolving filter
    filter_height = 13  # height of convolving filter
    filter_count = 3  # number of filters applied
    filter_stride = 1  # how far the filter moves between convolves
    filter_padding = 0  # padding around the input to use edge data (may not be useful with audio)
    downsample_count = 1  # how many times downsampling is performed
    downsample_multiplier = 2
    #   Layer 2:
    memory_dimension = 5  # number of hidden nodes in RNN

    # VARIABLES - FUNCTIONS
    activate = sigmoid
    d_activate = d_sigmoid

    # SETUP
    print("[INFO] Loading files")
    phones = load_list(phone_file)
    dictionary = ['<sil>'] + load_list(dictionary_file)
    transcript = load_transcript(transcript_file, transcript_type)
    words_to_phones = load_dictionary(dictionary_file)
    words_to_phones['<sil>'] = 'SIL'

    print("[INFO] Setting up features")
    audio_features, phone_features, word_features = setup_features(
        directory_path, phones, dictionary, transcript, words_to_phones)

    # GROUPING VARIABLES
    features = (audio_features, phone_features, word_features)

    # INITIALIZING
    # LAYER 1: AUDIO -> PHONES
    print("[INFO] Initializing LAYER 1: AUDIO -> PHONES")
    l1_input = np.matrix(audio_features[0]).shape
    l1_output = np.matrix(phone_features[0]).shape
    l1 = CNN(
        l1_input[0],
        l1_input[1],
        1,  # TODO: Change the inputs depending on the custom audio output
        filter_width,
        filter_height,
        filter_count,
        filter_stride,
        filter_padding,
        l1_output[0],
        l1_output[1],
        downsample_count,
        downsample_multiplier,
        activate,
        d_activate)

    # LAYER 2: PHONES -> WORDS
    print("[INFO] Initializing LAYER 2: PHONES -> WORDS")
    l2_input = l1_output
    l2_output = np.matrix(word_features[0]).shape
    l2 = RNN(l2_input[0], l2_input[1], l2_output[0], l2_output[1],
             memory_dimension, activate, d_activate)

    # NOTE: You can also simulate a sliding window using a CNN with a filter
    #       height the same as the input height!
    #       You might want to change the RNN to that if it produces better
    #       results.

    # MENU
    command = ''
    trained = False
    while (command != '0'):
        print("===================================")
        print('   NEURAL NETWORK OPTIONS:')
        print('   [1] Train network')
        print('   [2] Load an existing network')
        if trained:
            print('   [3] Test network')
            print('   [4] Demo network')
            print('   [5] Save network')
        print('   [0] Quit')
        print("===================================")
        try:
            command = int(input('What would you like to do? '))
        except (NameError, ValueError, SyntaxError):
            print('Invalid command!')
            continue
        else:
            if command == 0:
                # [0] Quit
                print('Bye!')
                break
            elif command == 1:
                # [1] Train network
                train_network(l1, l2, features, epoch, learning_rate,
                              dictionary, phones)
                trained = True
            elif command == 2:
                # [2] Load an existing network
                print('[INFO] Attempting to load existing network')
                if load(l1, l2):
                    trained = True
            elif command == 3 and trained:
                # [3] Test network
                # TODO: Testing function
                print('[ERROR] Not implemented')
                pass
            elif command == 4 and trained:
                # [4] Demo network
                # TODO: Demo function
                print('[ERROR] Not implemented')
                pass
            elif command == 5 and trained:
                # [5] Save network
                print('[INFO] Saving network')
                save(l1, l2)
            else:
                print('Invalid command!')

    return
import matplotlib.pyplot as plt

CLASS_LABELS = ['apple','banana','nectarine','plum','peach','watermelon','pear','mango','grape','orange','strawberry','pineapple',
    'radish','carrot','potato','tomato','bellpepper','broccoli','cabbage','cauliflower','celery','eggplant','garlic','spinach','ginger']

LITTLE_CLASS_LABELS = ['apple','banana','eggplant']

image_size = 90

random.seed(0)

classes = CLASS_LABELS
dm = data_manager(classes, image_size)

cnn = CNN(classes,image_size)

solver = Solver(cnn,dm)

solver.optimize()

plt.plot(solver.test_accuracy,label = 'Validation')
plt.plot(solver.train_accuracy, label = 'Training')
plt.legend()
plt.xlabel('Iterations (in 200s)')
plt.ylabel('Accuracy')
plt.show()

val_data = dm.val_data
train_data = dm.train_data
Esempio n. 25
0
def main(argv):
    print("CUDA_VISIBLE_DEVICES=", os.environ['CUDA_VISIBLE_DEVICES'])

    train_dir = FLAGS.train_dir
    dev_dir = FLAGS.dev_dir
    maps_dir = FLAGS.maps_dir

    if train_dir == '':
        print(
            'Must supply input data directory generated from tsv_to_tfrecords.py'
        )
        sys.exit(1)

    print('\n'.join(
        sorted([
            "%s : %s" % (str(k), str(v))
            for k, v in FLAGS.__dict__['__flags'].items()
        ])))

    with open(maps_dir + '/label.txt', 'r') as f:
        labels_str_id_map = {
            l.split('\t')[0]: int(l.split('\t')[1].strip())
            for l in f.readlines()
        }
        labels_id_str_map = {i: s for s, i in labels_str_id_map.items()}
        labels_size = len(labels_id_str_map)
    with open(maps_dir + '/token.txt', 'r') as f:
        vocab_str_id_map = {
            l.split('\t')[0]: int(l.split('\t')[1].strip())
            for l in f.readlines()
        }
        vocab_id_str_map = {i: s for s, i in vocab_str_id_map.items()}
        vocab_size = len(vocab_id_str_map)
    with open(maps_dir + '/shape.txt', 'r') as f:
        shape_str_id_map = {
            l.split('\t')[0]: int(l.split('\t')[1].strip())
            for l in f.readlines()
        }
        shape_id_str_map = {i: s for s, i in shape_str_id_map.items()}
        shape_domain_size = len(shape_id_str_map)
    with open(maps_dir + '/char.txt', 'r') as f:
        char_str_id_map = {
            l.split('\t')[0]: int(l.split('\t')[1].strip())
            for l in f.readlines()
        }
        char_id_str_map = {i: s for s, i in char_str_id_map.items()}
        char_domain_size = len(char_id_str_map)

    # with open(maps_dir + '/sizes.txt', 'r') as f:
    #     num_train_examples = int(f.readline()[:-1])

    print("num classes: %d" % labels_size)

    size_files = [
        maps_dir + "/" + fname for fname in listdir(maps_dir)
        if fname.find("sizes") != -1
    ]
    num_train_examples = 0
    num_tokens = 0
    for size_file in size_files:
        print(size_file)
        with open(size_file, 'r') as f:
            num_train_examples += int(f.readline()[:-1])
            num_tokens += int(f.readline()[:-1])

    print("num train examples: %d" % num_train_examples)
    print("num train tokens: %d" % num_tokens)

    dev_top_dir = '/'.join(
        dev_dir.split("/")[:-2]) if dev_dir.find("*") != -1 else dev_dir
    print(dev_top_dir)
    dev_size_files = [
        dev_top_dir + "/" + fname for fname in listdir(dev_top_dir)
        if fname.find("sizes") != -1
    ]
    num_dev_examples = 0
    num_dev_tokens = 0
    for size_file in dev_size_files:
        print(size_file)
        with open(size_file, 'r') as f:
            num_dev_examples += int(f.readline()[:-1])
            num_dev_tokens += int(f.readline()[:-1])

    print("num dev examples: %d" % num_dev_examples)
    print("num dev tokens: %d" % num_dev_tokens)

    # with open(dev_dir + '/sizes.txt', 'r') as f:
    #     num_dev_examples = int(f.readline()[:-1])

    type_set = {}
    type_int_int_map = {}
    outside_set = ["O", "<PAD>", "<S>", "</S>", "<ZERO>"]
    for label, id in labels_str_id_map.items():
        label_type = label if label in outside_set else label[2:]
        if label_type not in type_set:
            type_set[label_type] = len(type_set)
        type_int_int_map[id] = type_set[label_type]
    print(type_set)

    # load embeddings, if given; initialize in range [-.01, .01]
    embeddings_shape = (vocab_size - 1, FLAGS.embed_dim)
    embeddings = tf_utils.embedding_values(embeddings_shape, old=False)
    embeddings_used = 0
    if FLAGS.embeddings != '':
        with open(FLAGS.embeddings, 'r') as f:
            for line in f.readlines():
                split_line = line.strip().split(" ")
                word = split_line[0]
                embedding = split_line[1:]
                if word in vocab_str_id_map:
                    embeddings_used += 1
                    # shift by -1 because we are going to add a 0 constant vector for the padding later
                    embeddings[vocab_str_id_map[word] - 1] = map(
                        float, embedding)
                elif word.lower() in vocab_str_id_map:
                    embeddings_used += 1
                    embeddings[vocab_str_id_map[word.lower()] - 1] = map(
                        float, embedding)
    print("Loaded %d/%d embeddings (%2.2f%% coverage)" %
          (embeddings_used, vocab_size, embeddings_used / vocab_size * 100))

    layers_map = sorted(json.loads(FLAGS.layers.replace(
        "'", '"')).items()) if FLAGS.model == 'cnn' else None

    pad_width = int(layers_map[0][1]['width'] /
                    2) if layers_map is not None else 1

    with tf.Graph().as_default():
        train_batcher = Batcher(
            train_dir, FLAGS.batch_size) if FLAGS.memmap_train else SeqBatcher(
                train_dir, FLAGS.batch_size)

        dev_batch_size = FLAGS.batch_size  # num_dev_examples
        dev_batcher = SeqBatcher(dev_dir,
                                 dev_batch_size,
                                 num_buckets=0,
                                 num_epochs=1)
        if FLAGS.ontonotes:
            domain_dev_batchers = {
                domain: SeqBatcher(dev_dir.replace('*', domain),
                                   dev_batch_size,
                                   num_buckets=0,
                                   num_epochs=1)
                for domain in ['bc', 'nw', 'bn', 'wb', 'mz', 'tc']
            }

        train_eval_batch_size = FLAGS.batch_size
        train_eval_batcher = SeqBatcher(train_dir,
                                        train_eval_batch_size,
                                        num_buckets=0,
                                        num_epochs=1)

        char_embedding_model = BiLSTMChar(char_domain_size, FLAGS.char_dim, int(FLAGS.char_tok_dim/2)) \
            if FLAGS.char_dim > 0 and FLAGS.char_model == "lstm" else \
            (CNNChar(char_domain_size, FLAGS.char_dim, FLAGS.char_tok_dim, layers_map[0][1]['width'])
                if FLAGS.char_dim > 0 and FLAGS.char_model == "cnn" else None)
        char_embeddings = char_embedding_model.outputs if char_embedding_model is not None else None

        if FLAGS.model == 'cnn':
            model = CNN(num_classes=labels_size,
                        vocab_size=vocab_size,
                        shape_domain_size=shape_domain_size,
                        char_domain_size=char_domain_size,
                        char_size=FLAGS.char_tok_dim,
                        embedding_size=FLAGS.embed_dim,
                        shape_size=FLAGS.shape_dim,
                        nonlinearity=FLAGS.nonlinearity,
                        layers_map=layers_map,
                        viterbi=FLAGS.viterbi,
                        projection=FLAGS.projection,
                        loss=FLAGS.loss,
                        margin=FLAGS.margin,
                        repeats=FLAGS.block_repeats,
                        share_repeats=FLAGS.share_repeats,
                        char_embeddings=char_embeddings,
                        embeddings=embeddings)
        elif FLAGS.model == "bilstm":
            model = BiLSTM(num_classes=labels_size,
                           vocab_size=vocab_size,
                           shape_domain_size=shape_domain_size,
                           char_domain_size=char_domain_size,
                           char_size=FLAGS.char_dim,
                           embedding_size=FLAGS.embed_dim,
                           shape_size=FLAGS.shape_dim,
                           nonlinearity=FLAGS.nonlinearity,
                           viterbi=FLAGS.viterbi,
                           hidden_dim=FLAGS.lstm_dim,
                           char_embeddings=char_embeddings,
                           embeddings=embeddings)
        else:
            print(FLAGS.model + ' is not a valid model type')
            sys.exit(1)

        # Define Training procedure
        global_step = tf.Variable(0, name='global_step', trainable=False)

        optimizer = tf.train.AdamOptimizer(learning_rate=FLAGS.lr,
                                           beta1=FLAGS.beta1,
                                           beta2=FLAGS.beta2,
                                           epsilon=FLAGS.epsilon,
                                           name="optimizer")

        model_vars = tf.global_variables()

        print("model vars: %d" % len(model_vars))
        print(map(lambda v: v.name, model_vars))

        # todo put in func
        total_parameters = 0
        for variable in tf.trainable_variables():
            # shape is an array of tf.Dimension
            shape = variable.get_shape()
            variable_parametes = 1
            for dim in shape:
                variable_parametes *= dim.value
            total_parameters += variable_parametes
        print("Total trainable parameters: %d" % (total_parameters))

        if FLAGS.clip_norm > 0:
            grads, _ = tf.clip_by_global_norm(
                tf.gradients(model.loss, model_vars), FLAGS.clip_norm)
            train_op = optimizer.apply_gradients(zip(grads, model_vars),
                                                 global_step=global_step)
        else:
            train_op = optimizer.minimize(model.loss,
                                          global_step=global_step,
                                          var_list=model_vars)

        tf.global_variables_initializer()

        opt_vars = [
            optimizer.get_slot(s, n) for n in optimizer.get_slot_names()
            for s in model_vars if optimizer.get_slot(s, n) is not None
        ]
        model_vars += opt_vars

        if FLAGS.load_dir:
            reader = tf.train.NewCheckpointReader(FLAGS.load_dir + ".tf")
            saved_var_map = reader.get_variable_to_shape_map()
            intersect_vars = [
                k for k in tf.global_variables()
                if k.name.split(':')[0] in saved_var_map
                and k.get_shape() == saved_var_map[k.name.split(':')[0]]
            ]
            leftovers = [
                k for k in tf.global_variables()
                if k.name.split(':')[0] not in saved_var_map
                or k.get_shape() != saved_var_map[k.name.split(':')[0]]
            ]
            print("WARNING: Loading pretrained model, but not loading: ",
                  map(lambda v: v.name, leftovers))
            loader = tf.train.Saver(var_list=intersect_vars)

        else:
            loader = tf.train.Saver(var_list=model_vars)

        saver = tf.train.Saver(var_list=model_vars)

        sv = tf.train.Supervisor(
            logdir=FLAGS.model_dir if FLAGS.model_dir != '' else None,
            global_step=global_step,
            saver=None,
            save_model_secs=0,
            save_summaries_secs=0)

        training_start_time = time.time()
        with sv.managed_session(
                FLAGS.master,
                config=tf.ConfigProto(allow_soft_placement=True)) as sess:

            def run_evaluation(eval_batches, extra_text=""):
                predictions = []
                for b, (eval_label_batch, eval_token_batch, eval_shape_batch,
                        eval_char_batch, eval_seq_len_batch,
                        eval_tok_len_batch,
                        eval_mask_batch) in enumerate(eval_batches):
                    batch_size, batch_seq_len = eval_token_batch.shape

                    char_lens = np.sum(eval_tok_len_batch, axis=1)
                    max_char_len = np.max(eval_tok_len_batch)
                    eval_padded_char_batch = np.zeros(
                        (batch_size, max_char_len * batch_seq_len))
                    for b in range(batch_size):
                        char_indices = [
                            item for sublist in [
                                range(i * max_char_len, i * max_char_len + d)
                                for i, d in enumerate(eval_tok_len_batch[b])
                            ] for item in sublist
                        ]
                        eval_padded_char_batch[
                            b,
                            char_indices] = eval_char_batch[b][:char_lens[b]]

                    char_embedding_feeds = {} if FLAGS.char_dim == 0 else {
                        char_embedding_model.input_chars:
                        eval_padded_char_batch,
                        char_embedding_model.batch_size: batch_size,
                        char_embedding_model.max_seq_len: batch_seq_len,
                        char_embedding_model.token_lengths: eval_tok_len_batch,
                        char_embedding_model.max_tok_len: max_char_len
                    }

                    basic_feeds = {
                        model.input_x1: eval_token_batch,
                        model.input_x2: eval_shape_batch,
                        model.input_y: eval_label_batch,
                        model.input_mask: eval_mask_batch,
                        model.max_seq_len: batch_seq_len,
                        model.batch_size: batch_size,
                        model.sequence_lengths: eval_seq_len_batch
                    }

                    basic_feeds.update(char_embedding_feeds)
                    total_feeds = basic_feeds.copy()

                    if FLAGS.viterbi:
                        preds, transition_params = sess.run(
                            [model.predictions, model.transition_params],
                            feed_dict=total_feeds)

                        viterbi_repad = np.empty((batch_size, batch_seq_len))
                        for batch_idx, (unary_scores,
                                        sequence_lens) in enumerate(
                                            zip(preds, eval_seq_len_batch)):
                            viterbi_sequence, _ = tf.contrib.crf.viterbi_decode(
                                unary_scores, transition_params)
                            viterbi_repad[batch_idx] = viterbi_sequence
                        predictions.append(viterbi_repad)
                    else:
                        preds, scores = sess.run(
                            [model.predictions, model.unflat_scores],
                            feed_dict=total_feeds)
                        predictions.append(preds)

                if FLAGS.print_preds != '':
                    evaluation.print_conlleval_format(
                        FLAGS.print_preds, eval_batches, predictions,
                        labels_id_str_map, vocab_id_str_map, pad_width)

                # print evaluation
                f1_micro, precision = evaluation.segment_eval(
                    eval_batches,
                    predictions,
                    type_set,
                    type_int_int_map,
                    labels_id_str_map,
                    vocab_id_str_map,
                    outside_idx=map(
                        lambda t: type_set[t]
                        if t in type_set else type_set["O"], outside_set),
                    pad_width=pad_width,
                    start_end=FLAGS.start_end,
                    extra_text="Segment evaluation %s:" % extra_text)

                return f1_micro, precision

            threads = tf.train.start_queue_runners(sess=sess)
            log_every = int(max(100, num_train_examples / 5))

            if FLAGS.load_dir != '':
                print("Deserializing model: " + FLAGS.load_dir + ".tf")
                loader.restore(sess, FLAGS.load_dir + ".tf")

            def get_dev_batches(seq_batcher):
                batches = []
                # load all the dev batches into memory
                done = False
                while not done:
                    try:
                        dev_batch = sess.run(seq_batcher.next_batch_op)
                        dev_label_batch, dev_token_batch, dev_shape_batch, dev_char_batch, dev_seq_len_batch, dev_tok_len_batch = dev_batch
                        mask_batch = np.zeros(dev_token_batch.shape)
                        actual_seq_lens = np.add(
                            np.sum(dev_seq_len_batch,
                                   axis=1), (2 if FLAGS.start_end else 1) *
                            pad_width * ((dev_seq_len_batch != 0).sum(axis=1) +
                                         (0 if FLAGS.start_end else 1)))
                        for i, seq_len in enumerate(actual_seq_lens):
                            mask_batch[i, :seq_len] = 1
                        batches.append(
                            (dev_label_batch, dev_token_batch, dev_shape_batch,
                             dev_char_batch, dev_seq_len_batch,
                             dev_tok_len_batch, mask_batch))
                    except:
                        done = True
                return batches

            dev_batches = get_dev_batches(dev_batcher)
            if FLAGS.ontonotes:
                domain_batches = {
                    domain: get_dev_batches(domain_batcher)
                    for domain, domain_batcher in
                    domain_dev_batchers.iteritems()
                }

            train_batches = []
            if FLAGS.train_eval:
                # load all the train batches into memory
                done = False
                while not done:
                    try:
                        train_batch = sess.run(
                            train_eval_batcher.next_batch_op)
                        train_label_batch, train_token_batch, train_shape_batch, train_char_batch, train_seq_len_batch, train_tok_len_batch = train_batch
                        mask_batch = np.zeros(train_token_batch.shape)
                        actual_seq_lens = np.add(
                            np.sum(train_seq_len_batch, axis=1),
                            (2 if FLAGS.start_end else 1) * pad_width *
                            ((train_seq_len_batch != 0).sum(axis=1) +
                             (0 if FLAGS.start_end else 1)))
                        for i, seq_len in enumerate(actual_seq_lens):
                            mask_batch[i, :seq_len] = 1
                        train_batches.append(
                            (train_label_batch, train_token_batch,
                             train_shape_batch, train_char_batch,
                             train_seq_len_batch, train_tok_len_batch,
                             mask_batch))
                    except Exception as e:
                        done = True
            if FLAGS.memmap_train:
                train_batcher.load_and_bucket_data(sess)

            def train(max_epochs,
                      best_score,
                      model_hidden_drop,
                      model_input_drop,
                      until_convergence,
                      max_lower=6,
                      min_iters=20):
                print("Training on %d sentences (%d examples)" %
                      (num_train_examples, num_train_examples))
                start_time = time.time()
                train_batcher._step = 1.0
                converged = False
                examples = 0
                log_every_running = log_every
                epoch_loss = 0.0
                num_lower = 0
                training_iteration = 0
                speed_num = 0.0
                speed_denom = 0.0
                while not sv.should_stop(
                ) and training_iteration < max_epochs and not (
                        until_convergence and converged):
                    # evaluate
                    if examples >= num_train_examples:
                        training_iteration += 1

                        if FLAGS.train_eval:
                            run_evaluation(
                                train_batches,
                                "TRAIN (iteration %d)" % training_iteration)
                        print()
                        f1_micro, precision = run_evaluation(
                            dev_batches,
                            "TEST (iteration %d)" % training_iteration)
                        print("Avg training speed: %f examples/second" %
                              (speed_num / speed_denom))

                        # keep track of running best / convergence heuristic
                        if f1_micro > best_score:
                            best_score = f1_micro
                            num_lower = 0
                            if FLAGS.model_dir != '' and best_score > FLAGS.save_min:
                                save_path = saver.save(sess,
                                                       FLAGS.model_dir + ".tf")
                                print("Serialized model: %s" % save_path)
                        else:
                            num_lower += 1
                        if num_lower > max_lower and training_iteration > min_iters:
                            converged = True

                        # update per-epoch variables
                        log_every_running = log_every
                        examples = 0
                        epoch_loss = 0.0
                        start_time = time.time()

                    if examples > log_every_running:
                        speed_denom += time.time() - start_time
                        speed_num += examples
                        evaluation.print_training_error(
                            examples, start_time, [epoch_loss],
                            train_batcher._step)
                        log_every_running += log_every

                    # Training iteration

                    label_batch, token_batch, shape_batch, char_batch, seq_len_batch, tok_lengths_batch = \
                        train_batcher.next_batch() if FLAGS.memmap_train else sess.run(train_batcher.next_batch_op)

                    # make mask out of seq lens
                    batch_size, batch_seq_len = token_batch.shape

                    char_lens = np.sum(tok_lengths_batch, axis=1)
                    max_char_len = np.max(tok_lengths_batch)
                    padded_char_batch = np.zeros(
                        (batch_size, max_char_len * batch_seq_len))
                    for b in range(batch_size):
                        char_indices = [
                            item for sublist in [
                                range(i * max_char_len, i * max_char_len + d)
                                for i, d in enumerate(tok_lengths_batch[b])
                            ] for item in sublist
                        ]
                        padded_char_batch[
                            b, char_indices] = char_batch[b][:char_lens[b]]

                    max_sentences = max(map(len, seq_len_batch))
                    new_seq_len_batch = np.zeros((batch_size, max_sentences))
                    for i, seq_len_list in enumerate(seq_len_batch):
                        new_seq_len_batch[i, :len(seq_len_list)] = seq_len_list
                    seq_len_batch = new_seq_len_batch
                    num_sentences_batch = np.sum(seq_len_batch != 0, axis=1)

                    mask_batch = np.zeros(
                        (batch_size, batch_seq_len)).astype("int")
                    actual_seq_lens = np.add(
                        np.sum(seq_len_batch, axis=1),
                        (2 if FLAGS.start_end else 1) * pad_width *
                        (num_sentences_batch +
                         (0 if FLAGS.start_end else 1))).astype('int')
                    for i, seq_len in enumerate(actual_seq_lens):
                        mask_batch[i, :seq_len] = 1
                    examples += batch_size

                    # apply word dropout
                    # create word dropout mask
                    word_probs = np.random.random(token_batch.shape)
                    drop_indices = np.where(
                        (word_probs > FLAGS.word_dropout)
                        & (token_batch != vocab_str_id_map["<PAD>"]))
                    token_batch[drop_indices[0],
                                drop_indices[1]] = vocab_str_id_map["<OOV>"]

                    char_embedding_feeds = {} if FLAGS.char_dim == 0 else {
                        char_embedding_model.input_chars:
                        padded_char_batch,
                        char_embedding_model.batch_size:
                        batch_size,
                        char_embedding_model.max_seq_len:
                        batch_seq_len,
                        char_embedding_model.token_lengths:
                        tok_lengths_batch,
                        char_embedding_model.max_tok_len:
                        max_char_len,
                        char_embedding_model.input_dropout_keep_prob:
                        FLAGS.char_input_dropout
                    }

                    if FLAGS.model == "cnn":
                        cnn_feeds = {
                            model.input_x1: token_batch,
                            model.input_x2: shape_batch,
                            model.input_y: label_batch,
                            model.input_mask: mask_batch,
                            model.max_seq_len: batch_seq_len,
                            model.sequence_lengths: seq_len_batch,
                            model.batch_size: batch_size,
                            model.hidden_dropout_keep_prob: model_hidden_drop,
                            model.input_dropout_keep_prob: model_input_drop,
                            model.middle_dropout_keep_prob:
                            FLAGS.middle_dropout,
                            model.l2_penalty: FLAGS.l2,
                            model.drop_penalty: FLAGS.regularize_drop_penalty,
                        }
                        cnn_feeds.update(char_embedding_feeds)
                        _, loss = sess.run([train_op, model.loss],
                                           feed_dict=cnn_feeds)
                    elif FLAGS.model == "bilstm":
                        lstm_feed = {
                            model.input_x1: token_batch,
                            model.input_x2: shape_batch,
                            model.input_y: label_batch,
                            model.input_mask: mask_batch,
                            model.sequence_lengths: seq_len_batch,
                            model.max_seq_len: batch_seq_len,
                            model.batch_size: batch_size,
                            model.hidden_dropout_keep_prob:
                            FLAGS.hidden_dropout,
                            model.middle_dropout_keep_prob:
                            FLAGS.middle_dropout,
                            model.input_dropout_keep_prob: FLAGS.input_dropout,
                            model.l2_penalty: FLAGS.l2,
                            model.drop_penalty: FLAGS.regularize_drop_penalty
                        }
                        lstm_feed.update(char_embedding_feeds)
                        _, loss = sess.run([train_op, model.loss],
                                           feed_dict=lstm_feed)
                    epoch_loss += loss
                    train_batcher._step += 1
                return best_score, training_iteration, speed_num / speed_denom

            if FLAGS.evaluate_only:
                if FLAGS.train_eval:
                    run_evaluation(train_batches, "(train)")
                print()
                run_evaluation(dev_batches, "(test)")
                if FLAGS.ontonotes:
                    for domain, domain_batches in domain_batches.iteritems():
                        print()
                        run_evaluation(domain_batches, FLAGS.layers2 != '',
                                       "(test - domain: %s)" % domain)

            else:
                best_score, training_iteration, train_speed = train(
                    FLAGS.max_epochs,
                    0.0,
                    FLAGS.hidden_dropout,
                    FLAGS.input_dropout,
                    until_convergence=FLAGS.until_convergence)
                if FLAGS.model_dir:
                    print("Deserializing model: " + FLAGS.model_dir + ".tf")
                    saver.restore(sess, FLAGS.model_dir + ".tf")

            sv.coord.request_stop()
            sv.coord.join(threads)
            sess.close()

            total_time = time.time() - training_start_time
            if FLAGS.evaluate_only:
                print("Testing time: %d seconds" % (total_time))
            else:
                print(
                    "Training time: %d minutes, %d iterations (%3.2f minutes/iteration)"
                    % (total_time / 60, training_iteration, total_time /
                       (60 * training_iteration)))
                print("Avg training speed: %f examples/second" % (train_speed))
                print("Best dev F1: %2.2f" % (best_score * 100))
 number_cpus = parameters["number_cpus"][0]
 likert_score_file_path = parameters["likert_scores_file_path"][0]
 loss_function = parameters["loss_function"][0]
 dataset_loader = DatasetLoader(
     labels_file_path=labels_file_path,
     input_folder_path=input_folder_path,
     likert_scores_file_path=likert_score_file_path)
 index = dataset_loader.get_index(psychological_construct)
 labels = dataset_loader.labels
 run_config = tf.ConfigProto(device_count={'CPU': number_cpus})
 run_config.gpu_options.allow_growth = True
 with tf.Session(config=run_config) as sess:
     checkpoint_dir = parameters["checkpoint_dir"][0]
     checkpoint_dir = os.path.join(checkpoint_dir, psychological_construct)
     cnn_classifier = CNN(sess=sess,
                          epochs=epochs,
                          checkpoint_dir=checkpoint_dir,
                          loss=loss_function)
     predicted_values = []
     real_values = []
     for student in labels.keys():
         train_students = set(labels.keys()) - set([student])
         test_student = set([student])
         train_x, train_y = dataset_loader.get_x_and_y(
             students_set=train_students, index=index, test_flag=False)
         test_x, test_y = dataset_loader.get_x_and_y(
             students_set=test_student, index=index, test_flag=True)
         reshaped_train_set_x = dataset_loader.reshape_numpy_array(train_x)
         scaler = StandardScaler()
         scaler.fit(reshaped_train_set_x)
         normalized_reshaped_train_x = scaler.transform(
             reshaped_train_set_x)
Esempio n. 27
0
import numpy as np
from cnn import CNN
import matplotlib.pyplot as plt

code = 2
file_name = 'IL_weights_no_over'

il_nn = CNN()

history = il_nn.train(2 * 121)

plt.plot(history[0])
plt.xlabel('Epoch')
plt.ylabel('Cost')
plt.title('Cost Function Convergence')
plt.grid()
plt.savefig('convergence_{}.png'.format(code), format='png')

plt.figure()
plt.plot(history[1])
plt.xlabel('Epoch')
plt.ylabel('Val Acc')
plt.title('Validation Accuracy Convergence')
plt.grid()
plt.savefig('validation_{}.png'.format(code), format='png')

il_nn.save(file_name)

# history = il_nn.evaluate()
# print('evaluated_accuracy: {}'.format(history))
Esempio n. 28
0
# -*- coding: utf-8 -*-

from cnn import CNN
import pandas as pd

cnn = CNN()
data = pd.DataFrame()

data['cnn_feature'] = 0
data['cnn_feature'] = data['cnn_feature'].astype(object)

featurelist = cnn.get_features([
    '/home/seonhoon/Desktop/workspace/ImageQA/version_tensorflow/web/images/moodo.jpg'
],
                               layer='fc7')
data.loc[0, 'cnn_feature'] = featurelist[0].flatten()

data.to_pickle(
    '/home/seonhoon/Desktop/workspace/ImageQA/version_tensorflow/web/cnn.pkl')
Esempio n. 29
0
import matplotlib.pyplot as plt

from cnn import data_utils
from cnn.solver import Solver
from cnn import CNN
import numpy as np
data = data_utils.get_CIFAR10_data()
model = CNN.ThreeLayerConvNet(reg=0.9)
solver = Solver(model,
                data,
                lr_decay=0.95,
                print_every=10,
                num_epochs=5,
                batch_size=8,
                update_rule='sgd_momentum',
                optim_config={
                    'learning_rate': 5e-4,
                    'momentum': 0.9
                })

solver.train()

plt.subplot(2, 1, 1)
plt.title('Training loss')
plt.plot(solver.loss_history, 'o')
plt.xlabel('Iteration')

plt.subplot(2, 1, 2)
plt.title('Accuracy')
plt.plot(solver.train_acc_history, '-o', label='train')
plt.plot(solver.val_acc_history, '-o', label='val')
from mlp import MLP
from cnn import CNN
from utils import read_binary_data, get_training_and_test_data
import numpy as np

x_data, y_data = read_binary_data('kp-sorted-dataset', 100, 100)
(train_x, val_x, train_y, val_y) = get_training_and_test_data(x_data, y_data, percentage=0.6)

cnn_model = CNN(descriptor_width=100, descriptor_height=100)
scores = cnn_model.train(train_x, train_y, val_x, val_y, epochs=20, batch_size=16)
print scores


'''
cnn tried:
---------

self.model.add(Convolution2D(8, 5, 5))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(2, 2))
self.model.add(Convolution2D(16, 5, 5))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(4, 4))
self.model.add(Flatten())
self.model.add(Dense(3500))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.2))
self.model.add(Dense(1500))
self.model.add(Activation('relu'))
self.model.add(Dense(3))
self.model.add(Activation('softmax'))
Esempio n. 31
0
        #total_wrong += wrong
        idx += 1

    acc = cal_acc(labels, results, total_ori_cand)
    timestr = datetime.datetime.now().isoformat()
    logging.info("%s, evaluation loss:%s, acc:%s"%(timestr, total_loss/idx, acc))
    #logging.info("%s, evaluation loss:%s, acc:%s"%(timestr, total_loss/step, total_right/(total_right + total_wrong)))
#---------------------------------- execute valid model end --------------------------------------

#----------------------------------- begin to train -----------------------------------
with tf.Graph().as_default():
    with tf.device("/gpu:3"):
        gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=FLAGS.gpu_options)
        session_conf = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement, gpu_options=gpu_options)
        with tf.Session(config=session_conf).as_default() as sess:
            cnn = CNN(FLAGS.sequence_len, embedding, FLAGS.embedding_size, filter_sizes, FLAGS.num_filters)
            global_step = tf.Variable(0, name="global_step", trainable=False)
            optimizer = tf.train.AdamOptimizer(5e-2)
            #tf.train.GradientDescentOptimizer(1e-5)
            grads_and_vars = optimizer.compute_gradients(cnn.loss)
            train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)

            sess.run(tf.initialize_all_variables())

            #ori_quests, cand_quests = zip(*train_quests)
            #valid_ori_quests, valid_cand_quests = zip(*valid_quests)

            for ori_train, cand_train, neg_train in batch_iter(ori_quests, cand_quests, FLAGS.batch_size, FLAGS.epoches):
                run_step(sess, ori_train, cand_train, neg_train, cnn, FLAGS.dropout)
                cur_step = tf.train.global_step(sess, global_step)
                
Esempio n. 32
0
    cv2.rectangle(image, (x, y), (x + w, y + h), (255, 255, 204), 1)
    cv2.putText(image, CLASSES[prediction], (x, y), cv2.FONT_HERSHEY_DUPLEX,
                0.5, (255, 255, 102), 1, CV_AA)

    return image


test_image = cv2.imread(sys.argv[1])
face_rects = detect(test_image)
face_images = get_face_images(test_image, face_rects)

x = tf.placeholder(tf.float32, [None, PIXEL_COUNT])
labels = tf.placeholder(tf.float32, [None, len(CLASSES)])
keep_prob = tf.placeholder(tf.float32)

cnn = CNN(image_size=FLAGS.image_size, class_count=len(CLASSES))
y = cnn.inference(x, keep_prob, softmax=True)
sess = tf.InteractiveSession()
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
saver.restore(sess, os.path.join(LOG_DIR, 'model.ckpt'))

out_image = test_image.copy()

for i in range(len(face_images)):
    face_image = face_images[i]
    softmax = sess.run(y, feed_dict={
        x: [face_image],
        keep_prob: 1.0
    }).flatten()
    prediction = np.argmax(softmax)
Esempio n. 33
0
def fit_predict(data, labels, action, filename, test_datasets = [], learning_rate=0.1, n_epochs=20, nkerns=[20, 50], batch_size=500, seed=8000):
    rng = numpy.random.RandomState(seed)
    x = T.matrix('x')  # the data is presented as rasterized images
    y = T.ivector('y')  # the labels are presented as 1D vector of [int] labels
    index = T.lscalar()  # index to a [mini]batch
    if action=='fit':
        NUM_TRAIN = len(data)
        if NUM_TRAIN % batch_size != 0: #if the last batch is not full, just don't use the remainder
            whole = (NUM_TRAIN / batch_size) * batch_size
            data = data[:whole]
            NUM_TRAIN = len(data) 

        # random permutation
        indices = rng.permutation(NUM_TRAIN)
        data, labels = data[indices, :], labels[indices]
        
        # batch_size == 500, splits (480, 20). We will use 96% of the data for training, and the rest to validate the NN while training
        is_train = numpy.array( ([0]* (batch_size - 20) + [1] * 20) * (NUM_TRAIN / batch_size))
        
        # now we split the dataset to test and valid datasets
        train_set_x, train_set_y = numpy.array(data[is_train==0]), labels[is_train==0]
        valid_set_x, valid_set_y = numpy.array(data[is_train==1]), labels[is_train==1]
        # compute number of minibatches 
        n_train_batches = len(train_set_y) / batch_size
        n_valid_batches = len(valid_set_y) / batch_size

        ######################
        # BUILD ACTUAL MODEL #
        ######################
        print '... building the model'
        # allocate symbolic variables for the data
        epoch = T.scalar()
        #index = T.lscalar()  # index to a [mini]batch
        #x = T.matrix('x')  # the data is presented as rasterized images
        #y = T.ivector('y')  # the labels are presented as 1D vector of [int] labels
        
        # construct the CNN class
        classifier = CNN(
            rng=rng,
            input=x,
            nkerns = nkerns,
            batch_size = batch_size
        )

        train_set_x = theano.shared(numpy.asarray(train_set_x, dtype=theano.config.floatX))
        train_set_y = T.cast(theano.shared(numpy.asarray(train_set_y, dtype=theano.config.floatX)), 'int32')  
        valid_set_x = theano.shared(numpy.asarray(valid_set_x, dtype=theano.config.floatX)) 
        valid_set_y = T.cast(theano.shared(numpy.asarray(valid_set_y, dtype=theano.config.floatX)), 'int32')
        
        validate_model = theano.function(
            inputs=[index],
            outputs=classifier.errors(y),
            givens={
                x: valid_set_x[index * batch_size:(index + 1) * batch_size],
                y: valid_set_y[index * batch_size:(index + 1) * batch_size]
            }
        )

        cost = classifier.layer3.negative_log_likelihood(y)
        # create a list of gradients for all model parameters
        grads = T.grad(cost, classifier.params)

        # specify how to update the parameters of the model as a list of (variable, update expression) pairs
        updates = [
            (param_i, param_i - learning_rate * grad_i)
            for param_i, grad_i in zip(classifier.params, grads)
        ]

        # compiling a Theano function `train_model` that returns the cost, but
        # in the same time updates the parameter of the model based on the rules defined in `updates`
        train_model = theano.function(
            inputs=[index],
            outputs=cost,
            updates=updates,
            givens={
                x: train_set_x[index * batch_size: (index + 1) * batch_size],
                y: train_set_y[index * batch_size: (index + 1) * batch_size]
            }
        )




        ###############
        # TRAIN MODEL #
        ###############
        print '... training'
        best_iter = 0
        test_score = 0.
        start_time = time.clock()
        epoch = 0

        # here is an example how to print the current value of a Theano variable: print test_set_x.shape.eval()
        
        # start training
        while (epoch < n_epochs):
            epoch = epoch + 1   
            for minibatch_index in xrange(n_train_batches):
                minibatch_avg_cost = train_model(minibatch_index)
                iter = (epoch - 1) * n_train_batches + minibatch_index
                if (epoch) % 5  == 0 and minibatch_index==0:
                    # compute zero-one loss on validation set
                    validation_losses = [validate_model(i) for i
                                         in xrange(n_valid_batches)]
                    this_validation_loss = numpy.mean(validation_losses)

                    print(
                        'epoch %i, minibatch %i/%i, validation error %f %%' %
                        (
                            epoch,
                            minibatch_index + 1,
                            n_train_batches,
                            this_validation_loss * 100.
                        )
                    )

        ###############
        # PREDICTIONS #
        ###############

        # save and load
        f = file(filename, 'wb')
        cPickle.dump(classifier.__getstate__(), f, protocol=cPickle.HIGHEST_PROTOCOL)
        f.close()
        end_time = time.clock()              
        print >> sys.stderr, ('The code ran for %.2fm' % ((end_time - start_time) / 60.))


    if action == 'predict':
        # construct the CNN class
        classifier_2 = CNN(
            rng=rng,
            input=x,
            nkerns = nkerns,
            batch_size = batch_size
            )
        
        print "...."


        f = file(filename, 'rb')
        classifier_2.__setstate__(cPickle.load(f))
        f.close()


        RET = []
        for it in range(len(test_datasets)):
            test_data = test_datasets[it]
            N = len(test_data)
            test_data = theano.shared(numpy.asarray(test_data, dtype=theano.config.floatX))
            # just zeroes
            test_labels = T.cast(theano.shared(numpy.asarray(numpy.zeros(batch_size), dtype=theano.config.floatX)), 'int32')
        
            ppm = theano.function([index], classifier_2.layer3.pred_probs(),
                givens={
                    x: test_data[index * batch_size: (index + 1) * batch_size],
                    y: test_labels
                }, on_unused_input='warn')

            # p : predictions, we need to take argmax, p is 3-dim: (# loop iterations x batch_size x 2)
            p = [ppm(ii) for ii in xrange( N / batch_size)]  
            #p_one = sum(p, [])
            #print p
            p = numpy.array(p).reshape((N, 10))
            print p
            p = numpy.argmax(p, axis=1)
            p = p.astype(int)
            RET.append(p)
        return RET
Esempio n. 34
0

# Training
# ==================================================

with tf.Graph().as_default():
    session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)
    sess = tf.Session(config=session_conf)
    with sess.as_default():
        #embed()
        if (MODEL_TO_RUN == 0):
            model = CNN_LSTM(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim,filter_sizes,num_filters,l2_reg_lambda)
        elif (MODEL_TO_RUN == 1):
            model = LSTM_CNN(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim,filter_sizes,num_filters,l2_reg_lambda)
        elif (MODEL_TO_RUN == 2):
            model = CNN(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim,filter_sizes,num_filters,l2_reg_lambda)
        elif (MODEL_TO_RUN == 3):
            model = LSTM(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim)
        else:
            print ("PLEASE CHOOSE A VALID MODEL!\n0 = CNN_LSTM\n1 = LSTM_CNN\n2 = CNN\n3 = LSTM\n")
            exit();


        # Define Training procedure
        global_step = tf.Variable(0, name="global_step", trainable=False)
        optimizer = tf.train.AdamOptimizer(1e-3)
        grads_and_vars = optimizer.compute_gradients(model.loss)
        train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)

        # Keep track of gradient values and sparsity (optional)
        grad_summaries = []
Esempio n. 35
0
    pre_train_lr = 0.1
    pre_train_epoch = 10
    # node_shape = ((80,52), (74,46), (35,21))
    node_shape = ((80, 52), (74, 46), (34, 20))
    filter_shift_list = ((1, 1), (2, 2))
    input_shape = [80, 52]
    filter_shape = [7, 7]

    data_list = load_image(data_path, file_num, isRGB)

    makeFolder()

    # 時間計測
    time1 = time.clock()

    cnn1 = CNN(data_list, filter_shape, filter_shift_list[0], input_shape, node_shape[1], pre_train_lr, pre_train_epoch)

    output_list = cnn1.output()
    saveImage(output_list, node_shape[1], 'cnn1_before_training')

    cnn1.pre_train()
    output_list = cnn1.output()
    saveImage(output_list, node_shape[1], 'cnn1_after_training')

    # for i in xrange(pre_train_epoch):
    # 	cnn1.pre_train()
    # 	output_list = cnn1.output()
    # 	saveImage(output_list, (74,46))

    cnn2 = CNN(cnn1.output(), filter_shape, filter_shift_list[1], node_shape[1], node_shape[2], pre_train_lr, pre_train_epoch)
    output_list = cnn2.output()
Esempio n. 36
0
    def __init__(self):

        CNN.__init__(
            self,
            layers=[
                ('image_input', layers.InputLayer),
                ('image_conv1', layers.Conv2DLayer),
                ('image_pool1', layers.MaxPool2DLayer),
                ('image_conv2', layers.Conv2DLayer),
                ('image_pool2', layers.MaxPool2DLayer),
                ('prob_input', layers.InputLayer),
                ('prob_conv1', layers.Conv2DLayer),
                ('prob_pool1', layers.MaxPool2DLayer),
                ('prob_conv2', layers.Conv2DLayer),
                ('prob_pool2', layers.MaxPool2DLayer),
                ('binary_input', layers.InputLayer),
                ('binary_conv1', layers.Conv2DLayer),
                ('binary_pool1', layers.MaxPool2DLayer),
                ('binary_conv2', layers.Conv2DLayer),
                ('binary_pool2', layers.MaxPool2DLayer),
                ('border_input', layers.InputLayer),
                ('border_conv1', layers.Conv2DLayer),
                ('border_pool1', layers.MaxPool2DLayer),
                ('border_conv2', layers.Conv2DLayer),
                ('border_pool2', layers.MaxPool2DLayer),
                ('merge', layers.ConcatLayer),
                ('hidden3', layers.DenseLayer),
                ('output', layers.DenseLayer),
            ],

            # input
            image_input_shape=(None, 1, 75, 75),
            # conv2d + pool + dropout
            image_conv1_filter_size=(13, 13),
            image_conv1_num_filters=16,
            image_conv1_nonlinearity=nonlinearities.rectify,
            image_pool1_pool_size=(2, 2),
            # conv2d + pool + dropout
            image_conv2_filter_size=(13, 13),
            image_conv2_num_filters=16,
            image_conv2_nonlinearity=nonlinearities.rectify,
            image_pool2_pool_size=(2, 2),
            prob_input_shape=(None, 1, 75, 75),
            # conv2d + pool + dropout
            prob_conv1_filter_size=(13, 13),
            prob_conv1_num_filters=16,
            prob_conv1_nonlinearity=nonlinearities.rectify,
            prob_pool1_pool_size=(2, 2),
            # conv2d + pool + dropout
            prob_conv2_filter_size=(13, 13),
            prob_conv2_num_filters=16,
            prob_conv2_nonlinearity=nonlinearities.rectify,
            prob_pool2_pool_size=(2, 2),
            binary_input_shape=(None, 1, 75, 75),
            # conv2d + pool + dropout
            binary_conv1_filter_size=(13, 13),
            binary_conv1_num_filters=16,
            binary_conv1_nonlinearity=nonlinearities.rectify,
            binary_pool1_pool_size=(2, 2),
            # conv2d + pool + dropout
            binary_conv2_filter_size=(13, 13),
            binary_conv2_num_filters=16,
            binary_conv2_nonlinearity=nonlinearities.rectify,
            binary_pool2_pool_size=(2, 2),
            border_input_shape=(None, 1, 75, 75),
            # conv2d + pool + dropout
            border_conv1_filter_size=(13, 13),
            border_conv1_num_filters=16,
            border_conv1_nonlinearity=nonlinearities.rectify,
            border_pool1_pool_size=(2, 2),
            # conv2d + pool + dropout
            border_conv2_filter_size=(13, 13),
            border_conv2_num_filters=16,
            border_conv2_nonlinearity=nonlinearities.rectify,
            border_pool2_pool_size=(2, 2),

            # concat
            merge_incomings=[
                'image_pool2', 'prob_pool2', 'binary_pool2', 'border_pool2'
            ],

            # dense layer 1
            hidden3_num_units=256,
            hidden3_nonlinearity=nonlinearities.rectify,

            # dense layer 2
            output_num_units=2,
            output_nonlinearity=nonlinearities.softmax)
Esempio n. 37
0
batch_size = 10
input_shape = [3, 60, 40];


def random_matrix(shape, np_rng, name=None,type=floatX):
	return theano.shared(np.require(np_rng.randn(*shape), dtype=type),
			borrow=True, name=name)

# define inputs and filters
in_time       = 7
in_channels, in_width, in_height = input_shape;
flt_channels  = 10
flt_time      = 2
flt_width     = 3
flt_height    = 4
rng = np.random.RandomState(42)
#(batch, row, column, time, in channel)
train_x = random_matrix((batch_size, in_height, in_width, in_time, in_channels),rng, 'x');
train_y = random_matrix((batch_size,),rng,'y',type=np.dtype('int32'));

valid_x = random_matrix((batch_size, in_height, in_width, in_time, in_channels),rng, 'x');
valid_y = random_matrix((batch_size,),rng,'y',type=np.dtype('int32'));

numpy_rng = np.random.RandomState(89677)
#theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))

cnn = CNN(numpy_rng,batch_size=batch_size, n_outs=10,conv_layer_configs = conv_layer_configs,
	hidden_layer_configs=hidden_layer_configs);

train_fn, validate_fn = cnn.build_finetune_functions((train_x,train_y),
	(valid_x,valid_y), batch_size=batch_size)
Esempio n. 38
0
from data_provider import DataProvider
from ck_data_provider import CK_DataProvider
from fer2013_data_provider import FER2013_DataProvider

np.set_printoptions(threshold=np.inf)

LEARNING_RATE = 0.01
BATCH_SIZE = 50
EPOCH = 30
# WEIGHT_DECAY = 0.05

# data_provider = CK_DataProvider(BATCH_SIZE, 0)
data_provider = FER2013_DataProvider(BATCH_SIZE, 0)

cnn = CNN()
cnn_model = TrainModel(data_provider, LEARNING_RATE, EPOCH)
cnn_model.training(cnn, torch.optim.Adam(cnn.parameters(), lr=LEARNING_RATE),
                   nn.CrossEntropyLoss())

test_output = cnn(data_provider.x_validation)
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()

dummy_input = torch.tensor(np.expand_dims([np.random.rand(48, 48)], 1),
                           dtype=torch.float32)
torch.onnx.export(cnn, dummy_input, 'cnn_model.onnx', verbose=True)

onnx_model = onnx.load('cnn_model.onnx')
onnx.checker.check_model(onnx_model)

print('Export cnn_model.onnx complete!')
Esempio n. 39
0
    # load the model to use for performance evaluation

    x = T.matrix('x')

    rng = numpy.random.RandomState(1234)

    # retrieve the project settings from the database
    project = DB.getProject('evalcnn')

    # create the model based on the project
    model = CNN(
            rng=rng,
            input=x,
            offline=True,
            batch_size=project.batchSize,
            patch_size=project.patchSize,
            nkerns=project.nKernels,
            kernel_sizes=project.kernelSizes,
            hidden_sizes=project.hiddenUnits,
            train_time=project.trainTime,
            momentum=project.momentum,
            learning_rate=project.learningRate,
            path=project.path_offline,
            id=project.id)

    #data = Data( project )
    data = Data( project, offline=True, n_train_samples=700000, n_valid_samples=5000)
    model.train(data=data, offline=True, mean=project.mean, std=project.std)
    #print data.get_pixel_count(project)
Esempio n. 40
0
    # error checking
    if not opts.model_type in ["CNN", "MLP"]:
        raise ValueError(f"{opts.model_type} architecture not supported")

    # random seed for initializing weights
    if not opts.seed is None:
        torch.manual_seed(opts.seed)

    # getting data
    train_loader, valid_loader = load_data(batch_size=opts.batch_size)

    # both plots some sample data and gets the input size for the MLP
    input_size = None
    for images, labels in train_loader:
        input_size = (images.size(2), images.size(3))
        if opts.plot:
            plot_mnist_images(images.squeeze(), labels, 18)
            plt.close()
        break

    # creating model2
    num_classes = 10
    model = CNN(num_classes) if opts.model_type == "CNN" else MLP(input_size, num_classes)

    # training model
    final_statistics = train(model, train_loader, valid_loader, opts)

    # saving model
    if opts.save:
        torch.save(model, f"{opts.model_type.lower()}.pt")
        print(f"model saved as {opts.model_type.lower()}.pt")
Esempio n. 41
0
 def __init__(self):
     super(CRNN, self).__init__()
     self.cnn = CNN()
     self.rnn = RNN(input_size=2048, hidden_size=256, output_size=4)
if __name__ == '__main__':

    model_name = 'bs_64_lr_0.001_run_85'
    model_path = f'../logs/{model_name}/model.pt'

    resize_transform = transforms.Resize((360, 640))
    tensor_transform = transforms.ToTensor()

    image_path = f'../../train/0a0c3694-4cc8b0e3/0a0c3694-4cc8b0e3-8.png'

    image = Image.open(image_path)

    image_tensor = tensor_transform(resize_transform(image)).unsqueeze(0)

    model = CNN(640, 360, 3)

    model.load_state_dict(
        torch.load(model_path, map_location=torch.device('cpu')))
    model.eval()

    # Visualize feature maps
    activation = {}

    def get_activation(name):
        def hook(model, input, output):
            activation[name] = output.detach()

        return hook

    model.conv1.register_forward_hook(get_activation('conv1'))