def get_feature_map(idx):

    model = resnet18Conv5().cuda()

    mnist = MNIST(download=True, train=True, root=".").train_data.float()
    data_transform = Compose([
        Resize((224, 224)),
        ToTensor(),
        Normalize((mnist.mean() / 255, ), (mnist.std() / 255, ))
    ])
    mnist_dataset = MNIST(download=True,
                          root=".",
                          transform=data_transform,
                          train=True)

    print(len(mnist))
    data = mnist_dataset[idx]
    print("data shape = ", data[0].shape)  # data shape 1x224x224\
    print("data label = ", data[1])  # label number
    X = data[0].cuda()
    X = X.unsqueeze(0)
    outputs = model(X)
    outputs = outputs.detach().cpu().numpy()
    print(outputs.shape)
    return outputs
示例#2
0
def get_data_loaders(train_batch_size=256, val_batch_size=64):
    mnist = MNIST(download=True, train=True, root=".").train_data.float()

    # Ugly method to hardcode convert 1 channel grayscale to 3 channel RGB-like
    # but it is still gray input (due to MNIST from torchvision)
    data_transform = Compose([
        Resize((224, 224)),
        Grayscale(3),
        ToTensor(),
        Normalize((mnist.mean() / 255, ), (mnist.std() / 255, ))
    ])

    train_loader = DataLoader(MNIST(download=True,
                                    root=".",
                                    transform=data_transform,
                                    train=True),
                              batch_size=train_batch_size,
                              shuffle=True)

    val_loader = DataLoader(MNIST(download=True,
                                  root=".",
                                  transform=data_transform,
                                  train=False),
                            batch_size=val_batch_size,
                            shuffle=False)
    return train_loader, val_loader
def get_data_loaders(train_batch_size, val_batch_size):
    mnist = MNIST(download=False, train=True, root=".").train_data.float()
    
    data_transform = Compose([ Resize((224, 224)),ToTensor(), Normalize((mnist.mean()/255,), (mnist.std()/255,))])

    train_loader = DataLoader(MnistDataset(root_dir=''),
                              batch_size=train_batch_size, shuffle=True)

    val_loader = DataLoader(MnistDataset(root_dir='', training=False),
                            batch_size=val_batch_size, shuffle=False)
    return train_loader, val_loader
示例#4
0
def get_feature_map(idx):

    model = resnet18fc1000().cuda()

    mnist = MNIST(download=True, train=True, root=".").train_data.float()
    data_transform = Compose([ Resize((224, 224)),ToTensor(), Normalize((mnist.mean()/255,), (mnist.std()/255,))])    
    mnist_dataset = MNIST(download=True, root=".", transform=data_transform, train=True)
    data = mnist_dataset[idx]

    X = data[0].cuda()
    X = X.unsqueeze(0)
    
    outputs = model(X)

    return outputs
示例#5
0
def get_data_loaders(train_batch_size, val_batch_size):
    mnist = MNIST(download=False, train=True, root="./raw/").train_data.float()

    train_data_transform = Compose([
        RandomAffine(degrees=30,
                     translate=(0.15, 0.15),
                     scale=(0.9, 1.1),
                     shear=10),
        Resize((48, 48)),
        ToTensor(),
        Normalize((mnist.mean() / 255, ), (mnist.std() / 255, ))
    ])

    valid_data_transform = Compose([
        #RandomAffine(degrees=6, translate=(0.15, 0.15)),
        Resize((48, 48)),
        ToTensor(),
        Normalize((mnist.mean() / 255, ), (mnist.std() / 255, ))
    ])

    train_loader = DataLoader(MNIST(download=False,
                                    root=".",
                                    transform=train_data_transform,
                                    train=True),
                              batch_size=train_batch_size,
                              shuffle=True,
                              num_workers=4)

    val_loader = DataLoader(MNIST(download=False,
                                  root=".",
                                  transform=valid_data_transform,
                                  train=False),
                            batch_size=val_batch_size,
                            shuffle=False,
                            num_workers=4)
    return train_loader, val_loader
示例#6
0
import torch
import matplotlib.pyplot as plt
from biolayer import BioLinear
from visualization import LinearLayerVisualizer
from torchvision.datasets import MNIST

MNIST_DIR = '~/DataSets/'

Nc   = 10   # num. of classes
N    = 784  # Sample size
Nep  = 300  # Number of epochs
Num  = 100  # Batch size
eps0 = 2e-3 # Learning rate

Kx=5
Ky=5
hid=Kx*Ky    # number of hidden units that are displayed in Ky by Kx array

M = MNIST(MNIST_DIR, download=True).data.detach().view(-1, 28*28).float()
M -= M.mean(0)

bio_linear = BioLinear(N, hid)
vis = LinearLayerVisualizer(bio_linear, as_heatmap=True)

try:
	for weight in bio_linear.train(M, batch_size=Num, epsilon=eps0):
		vis.update()
except KeyboardInterrupt:
	vis.close()
	
import torch
### Load dataset
from torchvision.datasets import MNIST
from resnet_vis import *
import os
from sklearn.multiclass import OneVsRestClassifier
from sklearn.model_selection import train_test_split, GridSearchCV
#os.system('nvidia-smi -q -d Memory |grep -A4 GPU|grep Free >tmp')
#os.environ['CUDA_VISIBLE_DEVICES'] = str(np.argmax([int(x.split()[2]) for x in open('tmp', 'r').readlines()]))
#os.system('rm tmp')

mnist_train = MNIST(download=True, train=True, root=".").train_data.float()
data_transform = Compose([
    Resize((224, 224)),
    ToTensor(),
    Normalize((mnist_train.mean() / 255, ), (mnist_train.std() / 255, ))
])
mnist_dataset_train = MNIST(download=True,
                            root=".",
                            transform=data_transform,
                            train=True)

mnist_dataset_test = MNIST(download=True,
                           train=False,
                           root=".",
                           transform=data_transform)

#### Load ResNet 18 model to get features
resnet_model = resnet18Conv5().cuda()

### Generate train features
示例#8
0
class MyModel:
    def __init__(self):

        self.device = torch.device(
            "cuda:0" if torch.cuda.is_available() else "cpu")

        self.model = MnistResNet().to(self.device)

        try:
            self.model.load_state_dict(
                torch.load("./model/mnist_model_46_36.pth",
                           map_location="cpu"))
        except:
            self.model.load_state_dict(
                torch.load("mnist_model_46_36.pth", map_location="cpu"))

        self.model.eval()

        self.mnist = MNIST(download=True, train=True,
                           root=".").train_data.float()
        self.test_transforms = Compose([
            Resize(((46, 46))),
            ToTensor(),
            Normalize((self.mnist.mean() / 255, ), (self.mnist.std() / 255, ))
        ])

        self.BINARY_THREHOLD = 180

    def finetune(self):

        for param in self.model.parameters():
            param.require_grad = False

        print(self.model)

    def predict(self, image):

        with torch.no_grad():
            self.model.eval()
            image_tensor = self.test_transforms(image).float()
            image_tensor = image_tensor.unsqueeze_(0)
            input_ = Variable(image_tensor)
            input_ = input_.to(self.device)
            output = self.model(input_)
            index = output.data.cpu().numpy().argmax()
            return index

    def image_smoothening(self, img):
        ret1, th1 = cv2.threshold(img, self.BINARY_THREHOLD, 255,
                                  cv2.THRESH_BINARY)
        ret2, th2 = cv2.threshold(th1, 0, 255,
                                  cv2.THRESH_BINARY + cv2.THRESH_OTSU)
        blur = cv2.GaussianBlur(th2, (1, 1), 0)
        ret3, th3 = cv2.threshold(blur, 0, 255,
                                  cv2.THRESH_BINARY + cv2.THRESH_OTSU)
        return th3

    def remove_noise_and_smooth(self, file_name):
        img = cv2.imread(file_name, 0)
        h, w = img.shape

        #img[img <128] = 0
        img = img[int(w * 0.2):int(w * 0.9), int(h * 0.2):int(h * 0.9)]

        filtered = cv2.adaptiveThreshold(img.astype(np.uint8), 255,
                                         cv2.ADAPTIVE_THRESH_MEAN_C,
                                         cv2.THRESH_BINARY, 9, 41)
        kernel = np.ones((1, 1), np.uint8)
        opening = cv2.morphologyEx(filtered, cv2.MORPH_OPEN, kernel)
        closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
        img = self.image_smoothening(img)
        or_image = cv2.bitwise_or(img, closing)
        return or_image

    def remove_noise_and_smooth_numpy(self, image_np):
        img = cv2.cvtColor(image_np, cv2.COLOR_BGR2GRAY)

        h, w = img.shape

        #img[img <128] = 0
        img = img[int(w * 0.2):int(w * 0.9), int(h * 0.2):int(h * 0.9)]

        filtered = cv2.adaptiveThreshold(img.astype(np.uint8), 255,
                                         cv2.ADAPTIVE_THRESH_MEAN_C,
                                         cv2.THRESH_BINARY, 9, 41)
        kernel = np.ones((1, 1), np.uint8)
        opening = cv2.morphologyEx(filtered, cv2.MORPH_OPEN, kernel)
        closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
        img = self.image_smoothening(img)
        or_image = cv2.bitwise_or(img, closing)
        return or_image

    def preprocess_image(self, image):

        image = cv2.GaussianBlur(image, (7, 7), 0)

        h, w, c = image.shape

        image[image < 128] = 0

        # Convert BGR to HSV
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

        lower_val = np.array([110, 25, 50])
        upper_val = np.array([255, 255, 255])
        # Threshold the HSV image to get only black colors
        mask = cv2.inRange(hsv, lower_val, upper_val)

        # Bitwise-AND mask and original image
        image = cv2.bitwise_and(image, image, mask=mask)

        # invert the mask to get black letters on white background
        image = cv2.bitwise_not(image)

        #image = image[int(w*0.2): int(w*0.9),int(h*0.2): int(h*0.8)]

        #rimage = cv2.resize(image,(28,28))
        #rimage= np.moveaxis(rimage, 2, 0)
        #resized_image = np.reshape(rimage,(28,28,1))

        im_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        # rimage = np.expand_dims(im_gray, axis=0)
        # rimage= np.rollaxis(rimage, 3, 1)
        #

        return im_gray

    def main(self):

        file_in = "211851-1-2 copy.jpg"

        #image = cv2.imread(file_in)

        image = self.remove_noise_and_smooth(file_in)

        #image = preprocess_image(image)

        cv2.imwrite("test.jpg", image)

        to_pil = transforms.ToPILImage()

        pil_image = to_pil(image)
        index = predict(pil_image)

        print(index)

    def main_prediction(self, image_np):
        image_np = self.remove_noise_and_smooth_numpy(image_np)
        to_pil = transforms.ToPILImage()
        pil_image = to_pil(image_np)
        index = self.predict(pil_image)
        return index