def __init__(self, thymio_name):
"""init"""
self.net = Net()
self.net.load_state_dict(torch.load('./cnn', 'cpu'))
self.net.eval()
self.thymio_name = thymio_name
self.transform = transforms.Compose(
[
transforms.ToPILImage(),
transforms.ToTensor()
])
rospy.init_node('basic_thymio_controller', anonymous=True)
time.sleep(5)
self.velocity_publisher = rospy.Publisher(self.thymio_name + '/cmd_vel',
Twist, queue_size=10)
self.pose_subscriber = rospy.Subscriber(self.thymio_name + '/odom',
Odometry, self.update_state)
self.camera_subscriber = rospy.Subscriber(self.thymio_name + '/camera/image_raw',
Image, self.update_image, queue_size=1)
self.current_pose = Pose()
self.current_twist = Twist()
self.rate = rospy.Rate(10)
def __init__(self, hidden_dim, buffer_size, gamma, batch_size, device, writer):
self.env = make("connectx", debug=True)
self.device = device
self.policy = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.target = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.enemyNet = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.target.load_state_dict(self.policy.state_dict())
self.target.eval()
self.buffer = ExperienceReplay(buffer_size)
self.enemy = "random"
self.trainingPair = self.env.train([None, self.enemy])
self.loss_function = nn.MSELoss()
self.optimizer = optim.Adam(params=self.policy.parameters(), lr=0.001)
self.gamma = gamma
self.batch_size = batch_size
self.first = True
self.player = 1
self.writer = writer
def generate_experiment(method='FGSM'):
# define your model and load pretrained weights
# TODO
# model = ...
model = Net()
model = model.load_state_dict(
torch.load("/content/drive/My Drive/Colab Notebooks/model64"))
# cinic class names
import yaml
with open('./cinic_classnames.yml', 'r') as fp:
classnames = yaml.safe_load(fp)
# load image
# TODO:
# img_path = Path(....)
img_path = Path("/content/test/")
input_img = Image.open(img_path / "airplane/cifar10-test-10.png")
# define normalizer and un-normalizer for images
# cinic
mean = [0.47889522, 0.47227842, 0.43047404]
std = [0.24205776, 0.23828046, 0.25874835]
tf_img = transforms.Compose([
# transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std)
])
un_norm = transforms.Compose([
transforms.Normalize(mean=[-m / s for m, s in zip(mean, std)],
std=[1 / s for s in std]),
Clamp(),
transforms.ToPILImage()
])
# To be used for iterative method
# to ensure staying within Linf limits
clip_min = min([-m / s for m, s in zip(mean, std)])
clip_max = max([(1 - m) / s for m, s in zip(mean, std)])
input_tensor = tf_img(input_img)
attacker = AdversialAttacker(method=method)
return {
'img': input_img,
'inp': input_tensor.unsqueeze(0),
'attacker': attacker,
'mdl': model,
'clip_min': clip_min,
'clip_max': clip_max,
'un_norm': un_norm,
'classnames': classnames
}
def loading_model(model_path=BEST_MODEL_SAVE_PATH):
model = Net(resnet_level=24).to(DEVICE)
try:
print('===> Loading the saved model...')
model.load_state_dict(torch.load(model_path, map_location=DEVICE))
return model
except FileNotFoundError:
print('===> Loading the saved model fail, create a new one...')
return model
finally:
pass
class BasicThymio:
def __init__(self, thymio_name):
"""init"""
self.net = Net()
self.net.load_state_dict(torch.load('./cnn', 'cpu'))
self.net.eval()
self.thymio_name = thymio_name
self.transform = transforms.Compose(
[
transforms.ToPILImage(),
transforms.ToTensor()
])
rospy.init_node('basic_thymio_controller', anonymous=True)
time.sleep(5)
self.velocity_publisher = rospy.Publisher(self.thymio_name + '/cmd_vel',
Twist, queue_size=10)
self.pose_subscriber = rospy.Subscriber(self.thymio_name + '/odom',
Odometry, self.update_state)
self.camera_subscriber = rospy.Subscriber(self.thymio_name + '/camera/image_raw',
Image, self.update_image, queue_size=1)
self.current_pose = Pose()
self.current_twist = Twist()
self.rate = rospy.Rate(10)
def thymio_state_service_request(self, position, orientation):
"""Request the service (set thymio state values) exposed by
the simulated thymio. A teleportation tool, by default in gazebo world frame.
Be aware, this does not mean a reset (e.g. odometry values)."""
rospy.wait_for_service('/gazebo/set_model_state')
try:
model_state = ModelState()
model_state.model_name = self.thymio_name
model_state.reference_frame = '' # the frame for the pose information
model_state.pose.position.x = position[0]
model_state.pose.position.y = position[1]
model_state.pose.position.z = position[2]
qto = quaternion_from_euler(
orientation[0], orientation[1], orientation[2], axes='sxyz')
model_state.pose.orientation.x = qto[0]
model_state.pose.orientation.y = qto[1]
model_state.pose.orientation.z = qto[2]
model_state.pose.orientation.w = qto[3]
# a Twist can also be set but not recomended to do it in a service
gms = rospy.ServiceProxy('/gazebo/set_model_state', SetModelState)
response = gms(model_state)
return response
except rospy.ServiceException, e:
print "Service call failed: %s" % e
def loading_model():
if torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
else:
torch.set_default_tensor_type('torch.FloatTensor')
model = Net(resnet_level=24).to(DEVICE)
try:
print('===> Loading the saved model...')
model.load_state_dict(torch.load(MODEL_SAVE_PATH, map_location=DEVICE))
return model
except FileNotFoundError:
print('===> Loading the saved model fail, create a new one...')
return model
finally:
pass
def init_para():
start_time = time.perf_counter()
try:
print('===> Find the para_saved file')
open(PARA_SAVE_PATH)
except FileNotFoundError:
print('===> The para_saved file Not exist, creating new one...')
train_dataset_list = txt_to_path_list(TRAIN_DATA_PATH)
random.shuffle(train_dataset_list)
torch.save({
'epoch': EPOCH,
'batch_counter': BATCH_COUNTER,
'lr': LR,
'optimizer param_groups': torch.optim.Adam(Net().to(DEVICE).parameters(),
lr=LR,
betas=(0.9, 0.999),
eps=1e-08,
amsgrad=True).state_dict()['param_groups'][0],
'train_dataset_list': train_dataset_list,
'loss_list': [],
'result_list': [],
'hard_cases_list': [],
'best_result': [0, 0]
}, PARA_SAVE_PATH)
print('==> Done with initialization!')
finally:
print('===> Init_para used time: ', time.perf_counter() - start_time)
def __call__(self, draw = False):
# Load model
net = Net()
# Trained model
net.load_state_dict(torch.load('./saved_models/model_checkpoint_kpd.pt')['model'])
## print out your net and prepare it for testing (uncomment the line below)
net.eval()
## Data preparation
transformations = transforms.Compose([Rescale(250),
RandomCrop(224),
Normalize(),
ToTensor()])
# create the transformed dataset
transformed_data = KeypointsIterableDataset(self.image, self.keypoints, transform=transformations)
data_loader = DataLoader(transformed_data, num_workers=0)
## if train flag is set, Start training picking up old checkpoint
if self.train:
print("Training...")
## Run each record twice for training.
n_epochs = 2
train_net(n_epochs, data_loader, net)
## Get the prediction
print("Predicting...")
test_images, test_pts, gt_pts, sample = test_net(data_loader, net)
if draw:
visualize_output(test_images, test_pts)
# Rescaled.
return InverseTransform()(sample)
def __init__(self, model_file="baseline1.pth"):
# You should
# 1. create the model object
# 2. load your state_dict
# 3. call cuda()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model = Net()
self.mdl = NetObj()
self.modelObj = self.mdl.model
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
self.model = nn.DataParallel(self.model)
self.modelObj = nn.DataParallel(self.modelObj)
checkpoint = torch.load("baseline1.pth")
self.state_dict_1 = checkpoint['modelRoadMap_state_dict']
self.state_dict_2 = checkpoint['modelObjectDetection_state_dict']
self.model.load_state_dict(self.state_dict_1)
self.modelObj.load_state_dict(self.state_dict_2)
self.model.eval()
self.modelObj.eval()
self.model.to(device)
self.modelObj.to(device)
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from Model import Net
from modelobj import NetObj
import numpy as np
model = Net()
mdl = NetObj()
modelObj = mdl.model
checkpoint = torch.load("modelobj/fasterrcnn_model_19.pth")
checkpoint1 = torch.load("model1/resnet18_model2_20.pth")
state_dict_1 = checkpoint1['modelRoadMap_state_dict']
state_dict_2 = checkpoint['modelObjectDetection_state_dict']
model.load_state_dict(state_dict_1)
modelObj.load_state_dict(state_dict_2)
PATH = "baseline1.pth"
torch.save({'modelRoadMap_state_dict': state_dict_1, 'modelObjectDetection_state_dict': state_dict_2},PATH)
jj = int(w0*j/w)
newimg[i][j]=float(img[k][ii][jj])/n
return newimg
'''
def image_debug(env, h=100, w=100):
img = get_image(env)*255
img = Image.fromarray(img)
img.show()
envlist = []
envlist.append(gym.make('CartPole-v0'))
#envlist.append(gym.make('MountainCar-v0'))
model = Net()
model_freezed = copy.deepcopy(model)
print(model)
print(model_freezed)
done = False
tot_reward = 0
env = envlist[0]
eps_s = 1
eps_e = 0.1
play_time = 2000000
display_step = 200
gamma = 0.9
mb_size = 16
frame_skip = 2
def main():
global opt, model
opt = parser.parse_args()
print(opt)
cuda = opt.cuda
if cuda and not torch.cuda.is_available():
raise Exception("No GPU found, please run without --cuda")
opt.seed = random.randint(1, 10000)
print("Random Seed: ", opt.seed)
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
cudnn.benchmark = True
print("===> Loading datasets")
train_set = DatasetFromHdf5("data/train.h5")
training_data_loader = DataLoader(dataset=train_set,
num_workers=opt.threads,
batch_size=opt.batchSize,
shuffle=True)
print("===> Building model")
model = Net()
criterion = nn.MSELoss(size_average=False)
print("===> Setting GPU")
if cuda:
model = torch.nn.DataParallel(model).cuda()
criterion = criterion.cuda()
# optionally resume from a checkpoint
if opt.resume:
if os.path.isfile(opt.resume):
print("=> loading checkpoint '{}'".format(opt.resume))
checkpoint = torch.load(opt.resume)
opt.start_epoch = checkpoint["epoch"] + 1
model.load_state_dict(checkpoint["model"].state_dict())
else:
print("=> no checkpoint found at '{}'".format(opt.resume))
# optionally copy weights from a checkpoint
if opt.pretrained:
if os.path.isfile(opt.pretrained):
print("=> loading model '{}'".format(opt.pretrained))
weights = torch.load(opt.pretrained)
model.load_state_dict(weights['model'].state_dict())
else:
print("=> no model found at '{}'".format(opt.pretrained))
print("===> Setting Optimizer")
optimizer = optim.SGD(model.parameters(),
lr=opt.lr,
momentum=opt.momentum,
weight_decay=opt.weight_decay)
print("===> Training")
for epoch in range(opt.start_epoch, opt.nEpochs + 1):
train(training_data_loader, optimizer, model, criterion, epoch)
save_checkpoint(model, epoch)
class Trainer:
def __init__(self, hidden_dim, buffer_size, gamma, batch_size, device, writer):
self.env = make("connectx", debug=True)
self.device = device
self.policy = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.target = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.enemyNet = Net(self.env.configuration.columns * self.env.configuration.rows, hidden_dim,
self.env.configuration.columns).to(
device)
self.target.load_state_dict(self.policy.state_dict())
self.target.eval()
self.buffer = ExperienceReplay(buffer_size)
self.enemy = "random"
self.trainingPair = self.env.train([None, self.enemy])
self.loss_function = nn.MSELoss()
self.optimizer = optim.Adam(params=self.policy.parameters(), lr=0.001)
self.gamma = gamma
self.batch_size = batch_size
self.first = True
self.player = 1
self.writer = writer
def agent(self, observation, configuration):
with torch.no_grad():
state = torch.tensor(observation['board'], dtype=torch.float)
reshaped = self.reshape(state)
action = self.takeAction(self.enemyNet(reshaped).view(-1), reshaped, 0, False)
return action
def switch(self):
self.trainingPair = self.env.train([None, "negamax"])
self.enemy = "negamax"
def switchPosition(self):
self.env.reset()
if self.first:
self.trainingPair = self.env.train([self.enemy, None])
self.player = 2
else:
self.trainingPair = self.env.train([None, self.enemy])
self.player = 1
self.first = not self.first
def load(self, path):
self.policy.load_state_dict(torch.load(path))
def synchronize(self):
self.target.load_state_dict(self.policy.state_dict())
def save(self, name):
torch.save(self.policy.state_dict(), name)
def reset(self):
self.env.reset()
return self.trainingPair.reset()
def step(self, action):
return self.trainingPair.step(action)
def addExperience(self, experience):
self.buffer.append(experience)
def epsilon(self, maxE, minE, episode, lastEpisode):
return (maxE - minE) * max((lastEpisode - episode) / lastEpisode, 0) + minE
def change_reward(self, reward, done):
if done and reward == 1:
return 10
if done and reward == -1:
return -10
if reward is None and done:
return -20
if done:
return 1
if reward == 0:
return 1 / 42
else:
return reward
def change_reward_streak(self, reward, done, reshapedBoard, action, useStreak):
if done and reward == 1:
return 20
if done and reward == -1:
return -20
if reward is None and done:
return -40
if done:
return 1
if reward == 0 & useStreak:
return 1 / 42 + self.streakReward(self.player, reshapedBoard, action)
if reward == 0:
return 1 / 42
else:
return reward
def streakReward(self, player, reshapedBoard, action):
verticalReward = 0
horizontalReward = 0
if self.longestVerticalStreak(player, reshapedBoard, action) == 3:
verticalReward = 3
if self.longestHorizontalStreak(player, reshapedBoard, action) == 3:
horizontalReward = 3
return verticalReward + horizontalReward + self.longestDiagonalStreak(player, reshapedBoard, action)
def longestVerticalStreak(self, player, reshapedBoard, action):
count = 0
wasZero = False
for i in range(5, 0, -1):
if reshapedBoard[0][player][i][action] == 0:
wasZero = True
if reshapedBoard[0][player][i][action] == 1 & wasZero:
count = 0
wasZero = False
count += reshapedBoard[0][player][i][action]
if reshapedBoard[0][0][0][action] == 0:
return 0
return count
def longestHorizontalStreak(self, player, reshapedBoard, action):
count = 0
rowOfAction = self.rowOfAction(player, reshapedBoard, action)
wasZero = False
for i in range(7):
if reshapedBoard[0][player][rowOfAction][i] == 0:
wasZero = True
if reshapedBoard[0][player][rowOfAction][i] == 1 & wasZero:
count = 0
wasZero = False
count += reshapedBoard[0][player][rowOfAction][i]
return count
def longestDiagonalStreak(self, player, reshapedBoard, action):
rowOfAction = self.rowOfAction(player, reshapedBoard, action)
for row in range(4):
for col in range(5):
if reshapedBoard[0][player][row][col] == reshapedBoard[0][player][row + 1][col + 1] == \
reshapedBoard[0][player][row + 2][col + 2] == 1 and self.actionInDiagonal1(action, row, col,
rowOfAction):
return 3
for row in range(5, 1, -1):
for col in range(4):
if reshapedBoard[0][player][row][col] == reshapedBoard[0][player][row - 1][col + 1] == \
reshapedBoard[0][player][row - 2][col + 2] == 1 and self.actionInDiagonal2(action, row, col,
rowOfAction):
return 3
return 0
def actionInDiagonal1(self, action, row, col, rowOfAction):
return (rowOfAction == row and action == col or
rowOfAction == row + 1 and action == col + 1 or
rowOfAction == row + 2 and action == col + 2)
def actionInDiagonal2(self, action, row, col, rowOfAction):
return (rowOfAction == row and action == col or
rowOfAction == row - 1 and action == col + 1 or
rowOfAction == row - 2 and action == col + 2)
def rowOfAction(self, player, reshapedBoard, action):
rowOfAction = 10
for i in range(6):
if reshapedBoard[0][player][i][action] == 1:
rowOfAction = min(i, rowOfAction)
return rowOfAction
def policyAction(self, board, episode, lastEpisode, minEp=0.1, maxEp=0.9):
reshaped = self.reshape(torch.tensor(board))
output = self.policy(reshaped).view(-1)
return self.takeAction(output, reshaped, self.epsilon(maxEp, minEp, episode, lastEpisode))
def takeAction(self, actionList: torch.tensor, board, epsilon, train=True):
if (np.random.random() < epsilon) & train:
# invalide actions rein=geht nicht
#return torch.tensor(np.random.choice(len(actionList))).item()
return np.random.choice([i for i in range(len(actionList)) if board[0][0][0][i] == 1])
else:
for i in range(7):
if board[0][0][0][i] == 0:
actionList[i] = float('-inf')
return torch.argmax(actionList).item()
def reshape(self, board: torch.tensor, unsqz=True):
tensor = board.view(-1, 7).long()
# [0] = wo kann er reinwerfen(da wo es geht, steht eine 1), [1] = player1 (da wo es geht steht eine 0), [2] = player2 (da wo es geht steht eine 0)
a = F.one_hot(tensor, 3).permute([2, 0, 1])
b = a[:, :, :]
if unsqz:
return torch.unsqueeze(b, 0).float().to(self.device)
return b.float().to(self.device)
def preprocessState(self, state):
state = self.reshape(torch.tensor(state), True)
return state
def trainActionFromPolicy(self, state, action):
state = self.preprocessState(state)
value = self.policy(state).view(-1).to(self.device)
return value[action].to(self.device)
def trainActionFromTarget(self, next_state, reward, done):
next_state = self.preprocessState(next_state)
target = self.target(next_state)
target = torch.max(target, 1)[0].item()
target = reward + ((self.gamma * target) * (1 - done))
return torch.tensor(target).to(self.device)
def train(self):
if len(self.buffer) > self.batch_size:
self.optimizer.zero_grad()
states, actions, rewards, next_states, dones = self.buffer.sample(self.batch_size, self.device)
meanLoss = 0
for i in range(self.batch_size):
value = self.trainActionFromPolicy(states[i], actions[i])
target = self.trainActionFromTarget(next_states[i], rewards[i], dones[i])
loss = self.loss_function(value, target)
loss.backward()
meanLoss += loss
self.optimizer.step()
return meanLoss / self.batch_size
split = int(np.floor(validation_split * dataset_size))
if shuffle_dataset:
np.random.seed(random_seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_indices)
valid_sampler = SubsetRandomSampler(val_indices)
train_load = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
sampler=train_sampler)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
net = Net()
net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.7)
# Training
for epoch in range(5):
for i, data in enumerate(train_load, 0):
inputs, labels, name = data
inputs = inputs.float()
inputs, labels = inputs.to(device), labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
if type(m) == nn.Conv2d:
nn.init.xavier_uniform_(m.weight.data,
gain=nn.init.calculate_gain('conv2d'))
"""
Initialize network and relevant variables
"""
root_dir = r'data/'
num_epoch = 2
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('Using device:', device)
net = Net().to(device)
net.apply(init_weights)
"""
Load training data
"""
from torch.utils.data import DataLoader
from torchvision import transforms
composed = transforms.Compose([Normalize(), ToTensor()])
trainset = ImagesDataset(csv_file=root_dir + 'train.csv',
root_dir=root_dir,
transform=composed)
trainloader = DataLoader(trainset, batch_size=4, shuffle=True, num_workers=4)
"""
Train data
indices = list(range(dataset_size))
split = int(np.floor(validation_split * dataset_size))
if shuffle_dataset:
np.random.seed(random_seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
valid_sampler = SubsetRandomSampler(val_indices)
test_load = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
sampler=valid_sampler)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
net = Net()
net.load_state_dict(torch.load("./cnn", 'cpu'))
net.eval()
net.to(device)
class_correct = list(0. for i in range(3))
class_total = list(0. for i in range(3))
with torch.no_grad():
for i, data in enumerate(test_load):
print("%d/%d" % (i, len(test_load)), end="\r", flush=True)
images, labels, name = data
images, labels = images.float().to(device), labels.to(device)
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
label = labels.item()
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import time
from Model import Net
model = Net(10) #10 classes
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
if torch.cuda.is_available():
model = model.cuda()
criterion = criterion.cuda()
#from dataset import MeshData
#DataObject = MeshData(path)
st0 = time.time()
DataObject_X = np.load('x10.npy', allow_pickle=True)
DataObject_Y = np.load('y10.npy', allow_pickle=True)
st1 = time.time()
print(st1 - st0)
max_epochs = 30
for epochs in range(max_epochs):
#print('e =',epochs)z
running_loss = 0.0
st2 = time.time()
for i in range(len(DataObject_X)):
valLoader = torch.utils.data.DataLoader(validation_trainset, batch_size=args.batch_size, shuffle=True, num_workers=2, drop_last=True, collate_fn=collate_fn)
# In[ ]:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# In[ ]:
# import your model.
from Model import Net
model = Net()
print(model)
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
model = nn.DataParallel(model)
if args.reloadModel:
model_fp = "model4/resnet18_model2_17.pth"
model.load_state_dict(torch.load(model_fp)['modelRoadMap_state_dict'])
print("model_loaded")
model.to(device)
# In[ ]:
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from Model import Net
model = Net(10) #10 classes
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
from dataset import MeshData
DataObject = MeshData(
'/home/prathmesh/Desktop/SoC-2020/ModelNet10_stl/ModelNet10')
dataLoad = torch.utils.data.DataLoader(DataObject, batch_size=1, shuffle=True)
batch = next(iter(dataLoad))
print(len(batch))
max_epochs = 30
loss_list = []
for epochs in range(max_epochs):
#print('e =',epochs)
running_loss = 0.0
for i, data in enumerate(dataLoad, 0):
x, y = data
x = x[0].float().to(device)
#y = y.float()
y = y[0].to(device)
optimizer.zero_grad()
import torch
from Model import Net
import torchvision.transforms as transforms
#=========Setting up==============
#=======Loading weight file to the model========
from Dataset import load_split_train_test
from Model import Net
classes = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'del', 'nothing',
'space'
]
model = Net(out_fea=len(classes))
PATH = 'weight/epoch_6loss_0.15457870066165924.pt'
model.load_state_dict(torch.load(PATH))
model = model.eval()
img = cv2.imread(
'P:/Hand-Symbol-Recognition/asl_alphabet_test/asl_alphabet_test/J_test.jpg'
)
trans = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
img = trans(img)
img = img.unsqueeze(0)
shuffle=False)
test_loader = data.DataLoader(test_dataset,
batch_size=BATCH_SIZE,
shuffle=False)
loss_total = []
acc_total = []
pred_total = []
true_total = []
for i in tqdm(range(TOTAL)):
image_shape = full_dataset.x_data.shape[1:]
device = torch.device(CUDA_N if torch.cuda.is_available() else 'cpu')
torch.manual_seed(SEED[i])
net = Net(image_shape, NUM_CLASS)
net.to(device)
print(net)
softmax = nn.Softmax()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.1)
loss_list = []
train_acc_list = []
test_acc_list = []
pred_temp = []
true_temp = []
for epoch in range(EPOCH):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
dataiter = iter(train_loader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
#=============Defining Training Parameters and type of Device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = Net(out_fea=len(classes))
model = model.train()
model = model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
step = 0
loss_train = []
loss_val = []
min_loss = 100
patience = 5
training_loss_store = []
validation_loss_store = []
writer = SummaryWriter('writer')
class ModelLoader():
# Fill the information for your team
team_name = 'LAG'
team_member = ["Sree Gowri Addepalli"," Amartya prasad", "Sree Lakshmi Addepalli"]
round_number = 1
contact_email = '*****@*****.**'
def __init__(self, model_file="baseline1.pth"):
# You should
# 1. create the model object
# 2. load your state_dict
# 3. call cuda()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model = Net()
self.mdl = NetObj()
self.modelObj = self.mdl.model
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
self.model = nn.DataParallel(self.model)
self.modelObj = nn.DataParallel(self.modelObj)
checkpoint = torch.load("baseline1.pth")
self.state_dict_1 = checkpoint['modelRoadMap_state_dict']
self.state_dict_2 = checkpoint['modelObjectDetection_state_dict']
self.model.load_state_dict(self.state_dict_1)
self.modelObj.load_state_dict(self.state_dict_2)
self.model.eval()
self.modelObj.eval()
self.model.to(device)
self.modelObj.to(device)
def get_bounding_boxes(self,samples):
# samples is a cuda tensor with size [batch_size, 6, 3, 256, 306]
# You need to return a tuple with size 'batch_size' and each element is a cuda tensor [N, 2, 4]
# where N is the number of object
batch_size = list(samples.shape)[0]
# Convert it into [batch_size, 3, 512, 918]
img_tensor = self.combine_images(samples,batch_size)
tup_boxes = []
with torch.no_grad():
for img in img_tensor:
prediction = self.modelObj([img.cuda()])
cbox = self.convertBoundingBoxes(prediction[0]['boxes'])
#print(cbox.shape)
tup_boxes.append(cbox)
return tuple(tup_boxes)
def get_binary_road_map(self,samples):
# samples is a cuda tensor with size [batch_size, 6, 3, 256, 306]
# You need to return a cuda tensor with size [batch_size, 800, 800]
with torch.no_grad():
batch_size = list(samples.shape)[0]
sample = samples.reshape(batch_size,18,256,306)
output = self.model(sample)
#print(output.shape)
output = output.reshape(800,800)
return output
def combine_images(self, samples, batch_size):
# samples is a cuda tensor with size [batch_size, 6, 3, 256, 306]
# You need to return a tuple with size 'batch_size' and each element is a cuda tensor [N, 2, 4]
# where N is the number of object
ss = samples.reshape(batch_size, 2, 3, 3, 256, 306)
t = ss.detach().cpu().clone().numpy().transpose(0, 3, 2, 1, 4, 5)
# MergingImage
tp = np.zeros((batch_size, 3, 3, 512, 306))
for i in range(0, batch_size):
for j in range(0, 3):
for k in range(0, 3):
tp[i][j][k] = np.vstack([t[i][j][k][0], t[i][j][k][1]])
tr = np.zeros((batch_size, 3, 512, 918))
for i in range(0, batch_size):
for j in range(0, 3):
tr[i][j] = np.hstack([tp[i][j][0], tp[i][j][1], tp[i][j][2]])
image_tensor = torch.from_numpy(tr).float()
return image_tensor
def convertBoundingBoxes(self, boxes):
# convert [N,1,4] to [N,2,4]
if len(boxes) == 0:
boxes = [[0,0,0,0]]
convBoxes = []
for box in boxes:
xmin = box[0]
xmin = (xmin - 400)/10
ymin = box[1]
ymin = (-ymin +400)/10
xmax = box[2]
xmax = (xmax - 400)/10
ymax = box[3]
ymax = (-ymax + 400)/10
cbox = [[xmin,xmin,xmax,xmax], [ymin,ymax,ymin,ymax]]
convBoxes.append(cbox)
convBoxes = torch.Tensor(convBoxes)
return convBoxes
print(preprcess.TF_IDF_dict)
preprcess.wordbagGenerate()
preprcess.Save()
print('wordbag: ')
print(preprcess.wordbag)
print('label_list: ')
print(preprcess.label_list)
x = np.array(preprcess.wordbag)
y = np.array(preprcess.label_list)
x = torch.from_numpy(x).type(torch.FloatTensor)
y = torch.from_numpy(y)
x, y = Variable(x), Variable(y)
net = Net()
optimizer = torch.optim.ASGD(net.parameters(), lr=0.002)
criterion = torch.nn.CrossEntropyLoss()
for t in range(10000):
out = net(x)
loss = criterion(out, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if t % 100 == 0:
prediction = torch.max(F.softmax(out), 1)[1]
pred_y = prediction.data.numpy().squeeze()
target_y = y.data.numpy()
import torch
import torchvision
import torchvision.transforms as transforms
import torch.optim as optim
import torch.nn as nn
from Model import Net
net = Net()
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=4,
shuffle=True,
num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=transform)
testloader = torch.utils.data.DataLoader(testset,
batch_size=4,
shuffle=False,
num_workers=2)
import os
import csv
import torch
import torch.optim as optim
import torch.nn as nn
from Model import Net
from DataLoader import DataLoader
from sklearn.model_selection import train_test_split
PATH = os.path.join("./modified_kaggle_HW2")
net = Net()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)
net = nn.DataParallel(net)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
data_gen = DataLoader(PATH)
X_train_load, y_train_load, X_test = data_gen.load(preprocess=True)
def batch_feeder(X_train, y_train, batch_size):
X_mini = []
y_mini = []
for i in range(X_train.shape[0] // batch_size):
X_mini.append(X_train[i:i + batch_size])
y_mini.append(y_train[i:i + batch_size])
print(len(X_mini))
