Antoine Broyelle antoinebrl

Introduction

Assessesing the efficiency of various data structures in Python. The script introduces several ways to represent 3D points, utilizing both built-in structures like namedtuples, dataclasses (both with and without slots), standard classes, enums, and dictionaries, as well as custom structures like TensorDict and TensorClass. For TensorDict and TensorClass, certain tests separate the object creation from the timed segments.

Each data structure undergoes evaluation through functions made to access the coordinates within a loop.

Preparation of ImageNet (ILSVRC2012)

The dataset can be found on the official website if you are affiliated with a research organization. It is also available on Academic torrents.

This script extracts all the images and group them so that folders contain images that belong to the same class.

Download the ILSVRC2012_img_train.tar and ILSVRC2012_img_val.tar
Download the script wget https://gist.githubusercontent.com/antoinebrl/7d00d5cb6c95ef194c737392ef7e476a/raw/dc53ad5fcb69dcde2b3e0b9d6f8f99d000ead696/prepare.sh
Run it ./prepare.sh

Sources

Google XSS Challenges at https://xss-game.appspot.com
Help : https://www.google.com/about/appsecurity/learning/xss/index.html

Level 1: Hello, world of XSS

The output will be directly displayed without any escaping. A simple query with <script>alert("XSS")</script> will do the job.

	import torch
	from torch import nn
	from torch.utils.data import DataLoader
	from torchvision import datasets
	from torchvision.transforms import ToTensor, Lambda, Compose

	transform = Compose([ToTensor(), Lambda(lambda x: torch.flatten(x))])
	train_dataset = datasets.MNIST(root='data', train=True, transform=transform, download=True)
	test_dataset = datasets.MNIST(root='data', train=False, transform=transform)
	train_loader = DataLoader(train_dataset, batch_size=250, shuffle=True, drop_last=True)

	import timm
	import torchvision
	import torch
	import urllib
	from PIL import Image
	from torch import nn
	import onnx
	import onnx.helper as oh
	from onnx.onnx_pb import ValueInfoProto
	import numpy as np

	# Images have color pixels encoded as uint8. In computer
	# vision and deep learning the images is represented with
	# floatingpoints with value in the range [0,1]. This is
	# obtained by dividing by 255, the highest color intensity.
	# However, reduced precision training an inference become
	# the new standard.
	#
	# What is the magnitude of the rouding error when normalizing
	# an image by 255 rather than 256 (256=2^8)?

	import numpy as np
	from scipy.stats import mode


	def euclidean_distance(x1, x2):
	# x1 array of shape (N, D)
	# x2 array of shape (N', D)
	# output pairwise distances, array of shape (N, N')
	return np.linalg.norm(x1[:, np.newaxis] - x2, axis=1)

	import onnx

	model = onnx.load("model.onnx")
	graph = model.graph

	# Identify relevant node
	idx = -1
	for i, n in enumerate(model.graph.node):
	if n.name == "GlobalAveragePool":
	idx = i

	find . ! -user root -exec chown root:root {} \;
	find . -type f ! -perm 644 -exec chmod 644 {} \;
	find . -type d ! -perm 755 -exec chmod 755 {} \;