class SeldonModel:
def __init__(self):
self._model = Net()
self._model.load_state_dict(
torch.load("/storage/model.pkl", map_location=torch.device("cpu"))
)
self._model.eval()
def predict(self, X, features_names):
"""
Return a prediction.
Parameters
----------
X : array-like
feature_names : array of feature names (optional)
"""
data = transforms.ToTensor()(Image.open(io.BytesIO(X)))
return self._model(data[None, ...]).detach().numpy()
def send_feedback(self, features, feature_names, reward, truth):
"""
Handle feedback
Parameters
----------
features : array - the features sent in the original predict request
feature_names : array of feature names. May be None if not available.
reward : float - the reward
truth : array with correct value (optional)
"""
print("Send feedback called")
return []
def main():
# Training settings
# Use the command line to modify the default 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=14, metavar='N',
help='number of epochs to train (default: 14)')
parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
help='learning rate (default: 1.0)')
parser.add_argument('--step', type=int, default=1, metavar='N',
help='number of epochs between learning rate reductions (default: 1)')
parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
help='Learning rate step gamma (default: 0.7)')
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('--evaluate', action='store_true', default=False,
help='evaluate your model on the official test set')
parser.add_argument('--load-model', type=str,
help='model file path')
parser.add_argument('--save-model', action='store_true', default=True,
help='For Saving the current Model')
args = parser.parse_args()
torch.manual_seed(args.seed)
device = 'cpu'
kwargs = {}
# Evaluate on the official test set
if args.evaluate:
assert os.path.exists(args.load_model)
# Set the test model
model = Net().to(device)
model.load_state_dict(torch.load(args.load_model))
test_dataset = datasets.MNIST('data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=args.test_batch_size, shuffle=True, **kwargs)
test2(model, device, test_loader, errors=False, kernels=False, \
matrix=False, feature=False)
return
def main():
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
tfms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
img = tfms(Image.open(sys.argv[1]))
model = Net().to(device)
model.load_state_dict(torch.load("mnist_cnn.pt"))
test(model, device, img)
def run():
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
# Set the test model
model = Net().to(device)
model.load_state_dict(torch.load('./mnist_model_epoch=14.pt'))
test_dataset = datasets.MNIST('../data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_loader = torch.utils.data.DataLoader(
test_dataset, shuffle=False, **kwargs)
path = './model_mistakes.pkl'
if os.path.exists(path):
with open(path, 'rb') as f:
mistake_inds, pe_tuples, cm = pkl.load(f)
else:
with open(path, 'wb') as f:
mistake_inds, pe_tuples, cm = mark_mistakes(model, device, test_loader)
pkl.dump((mistake_inds, pe_tuples, cm), f)
# visualize_mistakes(mistake_inds, pe_tuples, test_dataset)
# visualize_kernels(model)
# confusion_matrix(cm)
path2 = './final_layer_outputs.pkl'
if os.path.exists(path2):
with open(path2, 'rb') as f:
fl_outputs = pkl.load(f)
else:
with open(path2, 'wb') as f:
fl_outputs = get_layer_outputs(model, device, test_loader)
pkl.dump(fl_outputs, f)
# t_sne_visualization(fl_outputs, test_dataset.targets)
find_nearby_images(fl_outputs, test_dataset)
def load_model():
model = Net()
model.load_state_dict(torch.load('model.pth'))
model.eval()
return model
import torch.optim
import torch.utils.data
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torchvision.models as models
import numpy as np
import numpy.random as r
import sklearn.metrics as m
from main import Net
import glob
model_dir = 'checkpoint_lite.pth.tar'
model = Net()
model = torch.nn.DataParallel(model).cuda()
checkpoint = torch.load(model_dir)
model.load_state_dict(checkpoint['state_dict'])
criterion = nn.CrossEntropyLoss().cuda()
model.eval()
#print(model.state_dict())
#print([i[0] for i in model.named_modules()])
#exit(0)
batch_num = 100
batch_size = 64
print(batch_size)
valdir = os.path.join('/train/trainset/1/DMS/data/', 'val_phone')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
from main import Net, test
import argparse
import torch
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Pytorch MNIST Load Test')
parser.add_argument('--cuda', action='store_true', default=False,
help='enables CUDA training')
parser.add_argument('--model', default='./mnist.dat')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
args = parser.parse_args()
use_cuda = args.cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print("Current Device:", device)
model = Net()
model.load_state_dict(torch.load(args.model, map_location=device))
dataloader_kwargs = {'pin_memory': True} if use_cuda else {}
test(args, model, device, dataloader_kwargs)
import pickle
import numpy as np
import cPickle
import json
import torch
import collections
from main import Net
# load the unpickle object into a variable
dict_pickle = cPickle.load(open("audio_model.pkl","r"))
if __name__ == '__main__':
#print dict_pickle
the_model = Net(39, 100, 10)
the_model.load_state_dict(torch.load("demo_model.pkl"))
x = the_model.state_dict().get('fc1.bias').numpy().reshape(1,100)
print x.dtype
#temp = np.zeros((3,4))
#newFile = open('output.txt', 'w')
#pickle.dump(the_model.state_dict().get('fc1.weight').numpy()[0], newFile)
np.savetxt('bias.txt', x, delimiter='\n')
#print the_model.state_dict().get('fc4.weight')
'''text_file = open("output.txt", "w")
text_file.write(dict_pickle['f2.weight'])
text_file.close()'''
return h
if __name__ == '__main__':
model_name = 'model.pt'
model_path = os.path.join(MODEL_PATH, model_name)
assert os.path.exists(model_path)
torch.manual_seed(1)
# Set the test model
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
model = Net().to(device)
model.load_state_dict(torch.load(model_path))
test_dataset = datasets.MNIST('./mnist_data', train=False,
transform=augmentation_scheme['augment1'])
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=32, shuffle=False, **kwargs)
img_idx = 7
os.makedirs(f'./close_feature_vectors/{img_idx}', exist_ok=True)
feature_vector_arr = get_feature_vectors(model, device, test_loader)
feature_vector = feature_vector_arr[img_idx]
closest_h = choose_closest_vector(feature_vector_arr, feature_vector)
test_dataset = datasets.MNIST('./mnist_data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
])),
batch_size=1,
shuffle=False)
# Define what device we are using
print("CUDA Available: ", torch.cuda.is_available())
device = torch.device("cuda" if (
use_cuda and torch.cuda.is_available()) else "cpu")
# Initialize the network
model = Net().to(device)
# Load the pretrained model
model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))
# Set the model in evaluation mode. In this case this is for the Dropout layers
model.eval()
accuracies = []
examples = []
acc, ex = test(model, device, test_loader, epsilon, runs, first_k)
accuracies.append(acc)
examples.append(ex)
# Plot several examples of adversarial samples at each epsilon
cnt = 0
plt.figure(figsize=(12, 8))
indices = [0]
# Some standard imports
import io
import numpy as np
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.onnx
import onnx
# import caffe2.python.onnx.backend as onnx_caffe2_backend
batch_size = 1 # just a random number
from main import Net
torch_model = Net()
torch_model.load_state_dict(
torch.load('/home/odedf/lw_model.pth', map_location='cpu'))
torch_model.eval()
x = torch.randn(batch_size, 3, 43, 43, requires_grad=True)
torch_out = torch.onnx._export(
torch_model, # model being run
x, # model input (or a tuple for multiple inputs)
"/home/odedf/lw_model.onnx", # where to save the model (can be a file or file-like object)
export_params=True
) # store the trained parameter weights inside the model file
# Load the ONNX ModelProto object. model is a standard Python protobuf object
model = torch.onnx.load("/home/odedf/lw_model.onnx")
# prepare the caffe2 backend for executing the model this converts the ONNX model into a
from flask import Flask, request, jsonify
import torch
import numpy as np
from torchvision.transforms import transforms
from main import Net
app = Flask(__name__)
PATH = "../MNIST-model/mnist_cnn.pt"
model = Net().double()
model.load_state_dict(torch.load(PATH))
trans = transforms.Compose([
transforms.ToTensor(),
])
@app.route('/predict', methods=['POST'])
def predict():
body = request.get_json()
img_array = np.asarray(body['indices'])
img_array = trans(img_array)
img_array = img_array.view(1, 1, 28, 28)
output = torch.exp(model(img_array.double()))
return jsonify({"output": int(np.argmax(output.detach().numpy()))})
if __name__ == '__main__':
app.run()
for key, val in classes.items():
if val == pred:
return key
return 'None'
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Test')
parser.add_argument('--image',
type=str,
default='YL (18).jpg',
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--use-cuda', action='store_true', default=False)
# parse argument
args = parser.parse_args()
device = torch.device('cuda' if args.use_cuda else 'cpu')
model = Net().to(device)
model.load_state_dict(torch.load(model_name))
image = cv2.imread(args.image)
pred_type = evaluate(image, model, device)
print(pred_type)
cv2.putText(image, pred_type, (10, 30), cv2.FONT_HERSHEY_COMPLEX, 1,
(255, 255, 255), 2)
cv2.namedWindow('Predict', cv2.WINDOW_NORMAL)
cv2.imshow('Predict', image)
cv2.waitKey(0)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
print("hello0")
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.test_batch_size, shuffle=True, **kwargs)
test_model = Net()
print("hello1")
#modules = [model]
#load_ckpt(modules, "net-epoch-20_baseline", load_to_cpu=False)
test_model.load_state_dict(torch.load("net-epoch-20_baseline.pth"))
test_model.train(False)
print("hello2")
if args.cuda:
test_model.cuda()
print("hello3")
test_model.eval()
test_loss = 0
correct = 0
for data, target in test_loader:
if args.cuda:
data, target = data.cuda(), target.cuda()
data, target = Variable(data, volatile=True), Variable(target)
output = test_model(data)
test_loss += F.nll_loss(output, target, size_average=False).data[0] # sum up batch loss
transform_test = transforms.Compose([transforms.ToTensor()])
test_set = ScatteredCIFAR10('./data',
train=False,
download=True,
transform=transforms.Compose([transform_test]))
test_gen = torch.utils.data.DataLoader(test_set,
pin_memory=True,
batch_size=128,
shuffle=False,
num_workers=4)
batch, _ = next(iter(test_gen))
inputs = batch[:16]
# Load models
stn = Net()
stn.load_state_dict(torch.load('standard1.49.pt')[torchbearer.MODEL])
multi = MultiScaleNet()
multi.load_state_dict(torch.load('multi1.49.pt')[torchbearer.MODEL])
fovea = FoveaNet(pool=True)
fovea.load_state_dict(torch.load('foveated1.49.pt')[torchbearer.MODEL])
stn_fa = Net(full_affine=True)
stn_fa.load_state_dict(torch.load('standardFA1.49.pt')[torchbearer.MODEL])
fovea_fa = FoveaNet(full_affine=True, pool=True)
fovea_fa.load_state_dict(torch.load('foveatedFA1.49.pt')[torchbearer.MODEL])
# Obtain transformed results
state = {}
