class KEY_AUTH():
_logout = False
def __init__(self, key, response=fake_response()):
self.connection = sqlite3.connect('database.db')
self.cursor = self.connection.cursor()
self.key = key
self.response = response
self.session = Session(self.connection, self.cursor)
self.credentials = (self.key, self.session.get(self.key)[3])
def login(self):
if self.session.checkexpiration(
self.key) == False or self._logout == True:
self.response.set_cookie('AUTH', 'None')
self.cursor.execute('UPDATE sessions SET expiration=? WHERE key=?',
(str(datetime.now()), self.key))
self.connection.commit()
self.response.headers['Refresh'] = '1'
return False
return True
def logout(self):
self._logout = True
def close(self):
self.connection.close()
def goodLogin(request):
logger = logging.getLogger("canvasLogger")
# its a POST, so credentials should have been supplied
username = request.POST.get('username', '')
pwd = request.POST.get('password', '')
try:
me = User.get_by_key_name(username)
except Exception:
logger.error('login: Exception - Username or Password Error')
try:
logger.error('login: Exception:' + sys.exc_type + sys.exc_value)
except:
pass
me = None
if me == None:
#FAILED LOGIN
Session()['message'] = "User Name and/or Password do not match"
logger.info('login failed: ' + username)
return False
else:
#good login
Session()['username'] = username
Session()['message'] = ""
logger.info('login good: ' + username)
#redirect to the page requestes, if there is one
redir = request.POST.get('page', username)
return True
assert (False)
def __init__(self, key, response=fake_response()):
self.connection = sqlite3.connect('database.db')
self.cursor = self.connection.cursor()
self.key = key
self.response = response
self.session = Session(self.connection, self.cursor)
self.credentials = (self.key, self.session.get(self.key)[3])
def test_basic_card(self):
Session.card_information = pull_card_data()
self.basicflag = Request(Flags.BASIC_CARDS, None, None, None)
self.session1 = Session([None, None])
body = str(Session.card_information['moves'])
size = len(body)
response_test = bytearray()
response_test.append(self.basicflag.flag)
_3byte = bytearray()
for i in range(0, 3):
_3byte.insert(0, size & 0xFF)
size >>= 8
response_test += _3byte
if isinstance(body, str):
response_test += body.encode('utf-8')
else:
response_test.append(body)
self.session1.basic_cards(self.basicflag)
self.assertIsNotNone(self.session1.last_response)
self.assertEqual(self.session1.last_response, response_test)
def poll_connections(server):
Logger.log("Server started")
Logger.log(server.getsockname())
connections = []
while server_running:
# Occasionally timeout from polling to check if the server is still running
try:
client, client_address = server.accept()
except sock.timeout:
continue
Logger.log("Anonymous user connected from address: " +
client_address[0])
new_session = Session((client, client_address))
new_session.start()
connections.append(new_session)
for connection in connections:
if connection.is_alive():
connection.kill()
server.shutdown(sock.SHUT_RDWR)
server.close()
Logger.log("Server stopped")
def logoff(request):
try:
room = Session()['room'] if 'room' in Session() else None
Session().delete()
if room:
return HttpResponseRedirect('/' + room + '/')
return HttpResponseRedirect('/login/')
except Error:
self.error(500)
def test_verify(self):
self.session1 = Session([None, None])
self.session1.userprofile = {'token': 'makeamericagreatagain'}
purrect_token = Request(None, 'makeamericagreatagain', None, None)
incorrect_token = Request(None, 'pokemon go to the polls', None, None)
self.assertFalse(self.session1.verified(purrect_token))
self.assertFalse(self.session1.verified(incorrect_token))
self.session1.authenticated = True
self.assertTrue(self.session1.verified(purrect_token))
self.assertFalse(self.session1.verified(incorrect_token))
def test_session_put():
test_session_data = {
"clientPhone": "425-999-9457",
"coachId": "coach2",
"time": "11",
"date": "2016-06-23",
"clientName": "Dong Ming"
}
test_put_session = Session(sessions=TEST_SESSION_DATA,
args=test_session_data)
with TEST_APP.test_request_context():
response, status = test_put_session.put('test_put_id')
assert response == test_session_data
assert status == 201
assert 'clientName' in response
assert response['clientName'] == 'Dong Ming'
def test_session_put():
test_session_data = {
"clientPhone": "425-999-9457",
"coachId": "coach2",
"time": "11",
"date": "2016-06-23",
"clientName": "Dong Ming"
}
test_put_session = Session(
sessions=TEST_SESSION_DATA, args=test_session_data)
with TEST_APP.test_request_context():
response, status = test_put_session.put('test_put_id')
assert response == test_session_data
assert status == 201
assert 'clientName' in response
assert response['clientName'] == 'Dong Ming'
def register(request):
def hash(str):
m = hashlib.md5()
m.update(settings.SECRET_KEY)
m.update(str)
return m.hexdigest()
if request.method == "GET":
t = get_template('login.html')
return HttpResponse(t.render([]))
else:
#add new user
username = request.POST.get("reg-username", '')
pwd = request.POST.get("reg-password1", "")
email = request.POST.get("reg-email", "")
if username != '':
newUser = User(key_name=username)
newUser.email = email
newUser.display_name = username
#newUser.key name = username
newUser.pwdHash = hash(pwd)
newUser.put()
Session()['username'] = username
#add a room for the user
#TODO: this is not the key
new_room = Room().get_by_key_name(username)
if new_room == None:
RoomUser().create_room(owner=newUser,
room_name=username,
is_public_read=False,
is_public_write=False)
return HttpResponseRedirect('/')
else:
return HttpResponseRedirect('/register/')
def create_normal_session():
# Create a user object, using session ID.
session_id = request.cookies.get('session', None)
g.user = Session(g.redis, session_id)
# Make sure we log the IP.
cf_connecting_ip = request.headers.get('CF-Connecting-IP')
if cf_connecting_ip is not None:
g.redis.hset('session.' + g.user.session_id + '.meta', 'last_ip',
cf_connecting_ip)
def allowed_read_access(room_name):
if 'username' in Session():
me = Session()['username']
else:
me = None
#valid login
#TODO: Check access to this room
db_room = Room().get_by_key_name(room_name)
if me == None:
user_me = None
else:
user_me = User().get_by_key_name(me)
if db_room:
if db_room.has_read_access(user_me):
return True
return False
def poll(request):
resp = '{"error": "Exception in Poll()"}'
if not request.GET:
return HttpResponseBadRequest
try:
#create logger
logger = logging.getLogger("canvasLogger")
me = Session()['username']
if (me == None) or (me == ''):
#not logged in
HttpResponseRedirect('/')
chatRoomName = request.GET.get('chatRoom')
lastStr = request.GET.get('lastMsg')
logger.debug('poll? - ' + chatRoomName + '/' + str(lastStr))
lastMsgSent = int(lastStr)
#TODO: Query msgs to see if any new (from anyone else)
#Check memcache for room's last ID
chatRoom = Room.get_by_key_name(chatRoomName)
lastId = chatRoom.get_lastMsgId()
logger.debug('poll? - Id:' + str(lastId))
msgs = ""
if lastMsgSent != lastId:
#a new msg
#return all msgs from lastMsg to lastId
q = db.GqlQuery(
"SELECT * FROM ChatMsg " +
"WHERE roomName = :1 AND seq > :2 " + "ORDER BY seq",
chatRoomName, lastMsgSent)
#, lastMsgSent)
logger.debug('poll? - querying')
msgs = ""
for msg in q:
msgs += "<br><b>"
msgs += msg.user.key().name()
msgs += ": </b>"
msgs += msg.text
logger.debug('poll? - msgs:' + msgs)
resp = '{"msg": "' + msgs + '", "lastMsgSeq": "' + str(lastId) + '"}'
#resp = HttpResponse('{"msg": "", "lastMsgSeq": "0"}', mimetype='application/javascript')
logger.debug("poll - " + e + '/' + chatRoomName + '/' + resp)
return HttpResponse('{"msg": "' + msgs + '", "lastMsgSeq": "' +
str(lastId) + '"}',
mimetype='application/javascript')
except Exception:
try:
resp = '{"error":"' + sys.exc_type + sys.exc_value + '"}'
finally:
return HttpResponse(resp, mimetype='application/javascript')
def logged_in():
try:
session = Session()
if 'username' in session:
return True
else:
Audit().log("ACCESS", "None", "Login required for " + f.__name__)
return False
except:
Audit().log("EXCEPTION", "unknown", "Login required for " + f.__name__)
return False
return True
def uploadImg(request):
#create logger
logger = logging.getLogger("canvasLogger")
file = request.FILES.get("imgUp", None)
if file:
page_name = request.POST.get('page')
Session()['page'] = page_name
room = Room().get_by_key_name(Session()['room'])
page = Page.gql('WHERE room = :room_key AND title = :title',
room_key=str(room.key()),
title=page_name).get()
if page:
pic = file.read()
dbpic = DbImage()
dbpic.picture = pic
dbpic.user = Session()['username']
dbpic.put()
#save the image to the content so its there when we reload (we are about to)
content = Content(parent=page)
content.page = str(page.key())
content.data = str(dbpic.key())
content.x = str(100 + random.randint(0, 100))
content.y = str(100 + random.randint(0, 100))
#TODO: set aspect ratio correctly
content.width = str(150)
content.height = str(150)
content.type = 'img'
content.deleted = False #for the transaction, mark as new
#content.title = contents[str(item_no)]['title']
content.put()
return HttpResponseRedirect('/' + room.key().name() + '/' +
page.title)
else:
return HttpResponse('<textarea>{error:"no page" }</textarea>',
mimetype='text/html')
else:
return HttpResponse('<textarea>{error:"no file" }</textarea>',
mimetype='text/html')
def poll_connections(server):
Logger.log("Server started")
Logger.log(server.getsockname())
while server_running:
# Occasionally timeout from polling to check if the server is still running
try:
client, client_address = server.accept()
except sock.timeout:
continue
Logger.log("Anonymous user connected from address: " +
client_address[0])
new_session = Session((client, client_address))
new_session.start()
Logger.log("Closing all sessions")
for live_thread in threading.enumerate():
if live_thread.name == 'session':
live_thread.kill()
active_count = threading.active_count()
while active_count >= 4:
update_count = threading.active_count()
if active_count > update_count:
active_count = update_count
Logger.log("Sessions remaining: " + str(active_count - 3))
Logger.log("*Safe to close server application*")
server.shutdown(sock.SHUT_RDWR)
server.close()
Logger.log("Server stopped")
class AUTH():
def __init__(self, response):
self.__key = str(uuid.uuid4())
self.connection = sqlite3.connect('database.db')
self.cursor = self.connection.cursor()
self.response = response
self.session = Session(self.connection, self.cursor)
def login(self, user, password):
password = self.hashps(password)
if self.cursor.execute(
'SELECT * FROM users WHERE username=? AND password=?',
(user, password)).fetchone() != None:
self.credentials = (self.__key, user, password)
self.response.set_cookie('AUTH', self.__key)
self.response.headers['Refresh'] = '1'
self.session.new(self.__key, user)
return "true"
else:
self.response.set_cookie('AUTH', 'None')
return "false"
def new(self, user, password):
if self.cursor.execute('SELECT id FROM users WHERE username=?',
(user, )).fetchone() == None:
self.cursor.execute(
'INSERT INTO users (username, password) VALUES (?,?)',
(user, self.hashps(password)))
self.connection.commit()
return True
return False
def hashps(self, password):
return hashlib.sha256(password).hexdigest()
def close(self):
self.connection.close()
def main(request):
logger = logging.getLogger("canvasLogger")
try:
room = Session()['room'] if 'room' in Session() else None
if room:
return HttpResponseRedirect('/' + room + '/')
t = get_template('index.html')
logger.debug("main: got_template")
return HttpResponse(t.render(main_context()))
except Exception:
#not logged in
logger.info("main: not logged in")
try:
logger.error("main: " + sys.exc_type)
Session(
)["message"] = 'Login Error:' + sys.exc_type + sys.exc_value
except:
try:
logger.error("main: exception logging in")
logger.error("main: username: " + Session()['username'])
del Session()['username']
except:
pass
return renderLogin()
def renderLogin():
try:
message = Session()["message"]
except KeyError:
message = ''
if (message != None) and (message != ""):
#str_message = pickle.loads(message)
template_values = Context({'error': message})
else:
template_values = Context()
t = get_template('login.html')
res = HttpResponse(t.render(template_values))
return res
def roomSettings(request):
if not request.POST:
return HttpResponseBadRequest
try:
my_email = Session()['username']
if (my_email == None) or (my_email == ''):
#not logged in
return HttpResponse('Not Logged In')
me = User().get_by_key_name(my_email)
#check I have permission to set this
roomName = request.POST.get("chatRoom")
room = Room.get_by_key_name(roomName)
if room:
if room.owner == str(me.key()):
#i am allowed - set it
#reset all initially
room.group_write = False
room.public_read = False
room.public_write = False
#READ ACCESS
#roomys can see if they exist
access_rd = request.POST.get("access-rd")
if access_rd == "world":
room.public_read = True
#WRITE ACCESS
#if there is a roomy, they can see it, but can only write if group_write set
access_wr = request.POST.get("access-wr")
if access_wr == "world":
room.public_write = True
if access_wr == "group":
room.group_write = True
#SAVE
room.put()
return HttpResponse(request.POST.get('label'))
return HttpResponse('error')
except Exception:
#create logger
logger = logging.getLogger("canvasLogger")
logger.error('roomSettings Exception:' + sys.exc_type + sys.exc_value)
#TODO: dont return anything if live
return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def page(request, room, page=None):
#open a page
logger = logging.getLogger("canvasLogger")
if page == '#':
page = None
try:
me = Session()['username']
except:
me = None
if (me == None) or (me == ''):
logger.info("page: not logged in [" + room + "]")
#valid login
#TODO: Check access to this room
if room:
db_room = Room().get_by_key_name(room)
if db_room:
if me == None:
user_me = None
else:
user_me = User().get_by_key_name(me)
if db_room.has_read_access(user_me):
logger.info("page: Access ok [" + room + "]")
Session()['room'] = room
if page:
Session()['page'] = page
else:
Session()['page'] = ""
#TODO: Exception here, need to render static welcome page
return render_to_response('index.html',
main_context(room_name=room))
else:
#no access to room
#TODO: error message
if 'room' in Session():
del Session()['room']
return HttpResponseRedirect("/")
#no room
if 'room' in Session():
del Session()['room']
return HttpResponseRedirect("/")
def buddiesChecklist(request):
if not request.GET:
return HttpResponseBadRequest
try:
my_email = Session()['username']
if (my_email == None) or (my_email == ''):
#not logged in
return HttpResponse('Not Logged In')
me = User().get_by_key_name(my_email)
t = get_template('buddieschecklist.html')
return HttpResponse(t.render(main_context()))
except Exception:
#create logger
logger = logging.getLogger("canvasLogger")
logger.error('buddiesChecklist Exception:' + sys.exc_type +
sys.exc_value)
#TODO: dont return anything if live
return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def newPage(request, room):
#add a page
if request.method == "GET":
logger.error('newPage: GET was not expected')
return HttpResponseBadRequest
try:
#Save Content of RTF editor
me = Session()['username']
if (me == None) or (me == ''):
#not logged in
logger.debug('saveContent: /')
HttpResponseRedirect('/')
#get room
room_name = request.POST.get('room')
room = Room().get_by_key_name(room_name)
user_me = User().get_by_key_name(me)
if room.has_write_access(str(user_me.key())):
#get page
page_name = request.POST.get('page')
page_key = pageNameToKey(room, page_name)
if page_key == None:
#page doesnt exist - create
newPage = Page()
newPage.room = str(room.key())
newPage.title = page_name
newPage.put()
resp = {"isOk": True, "pageName": page_name}
json_contents = simplejson.dumps(resp)
response = HttpResponse(json_contents,
mimetype='application/javascript')
return response
else:
logger.error('newPage: Page Exists')
return HttpResponseBadRequest
else:
logger.error('newPage: Access Denied')
return HttpResponseBadRequest
except:
logger.error('newPage: Exception')
return HttpResponseBadRequest
def acceptbuddy(request):
#accept a buddy request
if not request.POST:
return HttpResponseBadRequest
try:
my_email = Session()['username']
if (my_email == None) or (my_email == ''):
#not logged in
HttpResponseRedirect('/')
me = User().get_by_key_name(my_email)
new_buddy_name = request.POST.get('buddyName', '')
me.accept_buddy_request(new_buddy_name)
t = get_template('buddiespane.html')
return HttpResponse(t.render(main_context()))
except Exception:
#create logger
logger = logging.getLogger("canvasLogger")
logger.error('acceptbuddy Exception:' + sys.exc_type + sys.exc_value)
#TODO: dont return anything if live
return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def create_chat_session():
# Create a user object, using session and chat IDs.
session_id = request.cookies.get('session', None)
# If this is a health check let it pass
if request.path == '/health':
return
# Don't accept chat requests if there's no cookie.
if session_id is None:
abort(400)
# Validate session ID.
if session_validator.match(session_id) is None:
abort(400)
# Validate chat ID.
if 'chat' in request.form and validate_chat_url(request.form['chat']):
chat = request.form['chat']
else:
abort(400)
g.chat_type = g.redis.hget('chat.' + chat + '.meta', 'type')
if g.chat_type is None:
abort(404)
g.user = user = Session(g.redis, session_id, chat)
def addbuddy(request):
#add a new buddy
if not request.POST:
return HttpResponseBadRequest
try:
my_email = Session()['username']
if (my_email == None) or (my_email == ''):
#not logged in
HttpResponseRedirect('/')
me = User().get_by_key_name(my_email)
new_buddy_name = request.POST.get('buddyName', '')
#add outgoing req
me.add_buddy_request(new_buddy_name)
t = get_template('buddyreqspane.html')
return HttpResponse(t.render(main_context()))
except Exception:
print 'Exception:' + sys.exc_type + sys.exc_value
return HttpResponse('Exception:' + sys.exc_type + sys.exc_value)
def sendChat(request):
#create logger
logger = logging.getLogger("canvasLogger")
if not request.POST:
return HttpResponseBadRequest
try:
me = Session()['username']
if (me == None) or (me == ''):
#not logged in
HttpResponseRedirect('/')
msg = ChatMsg()
roomName = request.POST.get('chatRoom')
room = Room.get_by_key_name(roomName)
if room:
msg.chatRoom = room
msg.roomName = room.key().name(
) #needed cos you cant GQL query a key value!!!!!!
userMe = User.get_by_key_name(me)
if userMe:
msg.user = userMe
msg.text = request.POST.get('chatMsg')
msg.time = datetime.datetime.now()
msg.setId(room)
msg.put()
respTxt = '<br><b>' + me + ': </b>' + request.POST.get(
'chatMsg')
#lastId = room.get_lastMsgId()
resp = '{"msg":"' + respTxt + '", "lastMsgSeq": "' + str(
msg.seq) + '"}'
logger.debug("sendChat - " + resp)
return HttpResponse(resp, mimetype='application/javascript')
return HttpResponse('Exception: Room not found ' + roomName,
mimetype='application/javascript')
except Exception:
return HttpResponse('Exception:' + sys.exc_value,
mimetype='application/javascript')
def saveItem(request):
try:
room_name = request.POST.get('room')
room = Room().get_by_key_name(room_name)
me = Session()['username']
user_me = User().get_by_key_name(me)
if room.has_write_access(str(user_me.key())):
#get page
page_name = request.POST.get('page')
page_key = pageNameToKey(room, page_name)
if page_key == None:
logger.error('SaveContent: NO PAGE: room:' + room_name +
' page:' + page_name)
return HttpResponseServerError
#good page, and we have access
item = simplejson.loads(request.POST.get('item'))
try:
content = Content.get(item["key"])
except:
content = Content(parent=Page().get(page_key))
if content:
content.page = page_key
content.data = item['data']
content.x = "10px" if (item['x'] == "") else item['x']
content.y = "10px" if (item['y'] == "") else item['y']
content.width = item['width']
content.height = item['height']
content.type = item['type']
content.deleted = False #for the transaction, mark as new
#content.title = contents[str(item_no)]['title']
content.put()
return HttpResponse('ok', mimetype='application/javascript')
else:
return HttpResponseServerError
except:
pass
return HttpResponseServerError
def train_protonetmhlnbs(base_subdataset: LabeledSubdataset, val_subdataset: LabeledSubdataset, n_shot: int, n_way: int,
n_iterations: int, batch_size: int, eval_period: int,
val_batch_size: int,
image_size: int,
balanced_batches: bool,
train_n_way=15,
backbone_name='resnet12-np-o',
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"), **kwargs):
session_info = {
"task": "few-shot learning",
"model": "ProtoNetMHLNBS",
"feature_extractor": backbone_name,
"n_iterations": n_iterations,
"eval_period": eval_period,
# "dataset": dataset_name,
# "optimizer": optimizer_name,
"batch_size": batch_size,
"val_batch_size": val_batch_size,
"n_shot": n_shot,
"n_way": n_way,
"train_n_way": train_n_way,
"optimizer": 'adam',
"image_size": image_size,
"balanced_batches": balanced_batches,
}
session_info.update(kwargs)
backbone = FEATURE_EXTRACTORS[backbone_name]()
model = ProtoNet_MHLNBS(backbone=backbone).to(device)
optimizer = OPTIMIZERS['adam'](model=model)
base_sampler = FSLEpisodeSampler(subdataset=base_subdataset, n_way=train_n_way, n_shot=n_shot,
batch_size=batch_size, balanced=balanced_batches)
val_sampler = FSLEpisodeSampler(subdataset=val_subdataset, n_way=n_way, n_shot=n_shot, batch_size=val_batch_size,
balanced=balanced_batches)
loss_plotter = PlotterWindow(interval=1000)
accuracy_plotter = PlotterWindow(interval=1000)
loss_plotter.new_line('Loss')
loss_plotter.new_line('Loss Instance')
accuracy_plotter.new_line('Train Accuracy')
accuracy_plotter.new_line('Validation Accuracy')
losses = []
losses_i = []
acc_train = []
acc_val = []
val_iters = []
best_accuracy = 0
best_iteration = -1
print("Training started for parameters:")
print(session_info)
print()
start_time = time.time()
for iteration in range(n_iterations):
model.train()
support_set, batch = base_sampler.sample()
# print(support_set.size())
query_set, query_labels = batch
# print(query_set.size())
# print(global_classes_mapping)
query_set = query_set.to(device)
query_labels = query_labels.to(device)
optimizer.zero_grad()
output, loss, loss_i = model.forward_with_loss(support_set, query_set, query_labels)
loss.backward()
optimizer.step()
labels_pred = output.argmax(dim=1)
labels = query_labels
cur_accuracy = accuracy(labels=labels, labels_pred=labels_pred)
loss_plotter.add_point('Loss', iteration, loss.item())
loss_plotter.add_point('Loss Instance', iteration, loss_i.item())
accuracy_plotter.add_point('Train Accuracy', iteration, cur_accuracy)
losses.append(loss.item())
losses_i.append(loss_i.item())
acc_train.append(cur_accuracy)
if iteration % eval_period == 0 or iteration == n_iterations - 1:
val_start_time = time.time()
val_accuracy = evaluate_solution_episodes(model, val_sampler)
accuracy_plotter.add_point('Validation Accuracy', iteration, val_accuracy)
acc_val.append(val_accuracy)
val_iters.append(iteration + 1)
if val_accuracy > best_accuracy:
best_accuracy = val_accuracy
best_iteration = iteration
print("Best evaluation result yet!")
cur_time = time.time()
val_time = cur_time - val_start_time
time_used = cur_time - start_time
time_per_iteration = time_used / (iteration + 1)
print()
print("[%d/%d] = %.2f%%\t\tLoss: %.4f" % (
iteration + 1, n_iterations, (iteration + 1) / n_iterations * 100, loss.item()))
print("Current validation time: %s" % pretty_time(val_time))
print('Average iteration time: %s\tEstimated execution time: %s' % (
pretty_time(time_per_iteration),
pretty_time(time_per_iteration * (n_iterations - iteration - 1)),
))
print()
cur_time = time.time()
training_time = cur_time - start_time
print("Training finished. Total execution time: %s" % pretty_time(training_time))
print("Best accuracy is: %.3f" % best_accuracy)
print("Best iteration is: [%d/%d]" % (best_iteration + 1, n_iterations))
print()
session_info['accuracy'] = best_accuracy
session_info['best_iteration'] = best_iteration
session_info['execution_time'] = training_time
session = Session()
session.build(name="ProtoNetMHLNBS", comment=r"ProtoNet with Mahalanobis distance Few-Shot Learning",
**session_info)
torch.save(model, os.path.join(session.data['output_dir'], "trained_model_state_dict.tar"))
iters = list(range(1, n_iterations + 1))
plt.figure(figsize=(20, 20))
plt.plot(iters, losses, label="Loss")
plt.plot(iters, losses_i, label="Loss Instance")
plt.legend()
plt.savefig(os.path.join(session.data['output_dir'], "loss_plot.png"))
plt.figure(figsize=(20, 20))
plt.plot(iters, acc_train, label="Train Accuracy")
plt.plot(val_iters, acc_val, label="Test Accuracy")
plt.legend()
plt.savefig(os.path.join(session.data['output_dir'], "acc_plot.png"))
session.save_info()
def fit(self, support_set: torch.Tensor):
self.n_classes = support_set.size(0)
def transform(self, x: torch.Tensor):
if len(x.size()) == 3:
x = torch.unsqueeze(x, 0)
self.n_query = x.size(0)
prob = F.softmax(torch.rand(self.n_query, self.n_classes), dim=1)
if prob.size(0) == 1:
prob = torch.squeeze(prob, 0)
return prob
if __name__ == '__main__':
best_model = RandomClassifier()
session_info = {
"task": "few-shot learning",
"model": "RANDOM",
}
session = Session()
session.build(name="RANDOM", comment=r"RANDOM classifier", **session_info)
torch.save(
best_model,
os.path.join(session.data['output_dir'],
"trained_model_state_dict.tar"))
session.save_info()
#!/usr/bin/env python3
import argparse
from sessions import Session
def handle_arguments():
"""
:return: commandline arguments
"""
info = "usage: give port number and target host as commandline arguments."
parser = argparse.ArgumentParser(description=info)
parser.add_argument("mode",
help="Usage mode 'client' or 'proxy'",
type=str)
parser.add_argument("udp_port", help="Port to listen on client.", type=int)
parser.add_argument("target_host", help="Target hosts address.")
args = parser.parse_args()
return args
if __name__ == '__main__':
args = handle_arguments()
mode = args.mode
host = args.target_host
udp_port = args.udp_port
session = Session(udp_port, host, mode)
