def t_action_on_basis(self, perm, i):
"""
EXAMPLES::
sage: H3 = HeckeAlgebraSymmetricGroupT(QQ, 3)
sage: H3.t_action_on_basis(Permutation([2,1,3]), 1)
q*T[1, 2, 3] + (q-1)*T[2, 1, 3]
sage: H3.t_action_on_basis(Permutation([1,2,3]), 1)
T[2, 1, 3]
sage: H3 = HeckeAlgebraSymmetricGroupT(QQ, 3, 1)
sage: H3.t_action_on_basis(Permutation([2,1,3]), 1)
T[1, 2, 3]
sage: H3.t_action_on_basis(Permutation([1,3,2]), 2)
T[1, 2, 3]
"""
if i not in range(1, self.n):
raise ValueError, "i must be between 1 and n (= %s)"%self.n
t_i = permutation.Permutation( (i, i+1) )
perm_i = t_i * perm
if perm[i-1] < perm[i]:
return self(perm_i)
else:
#Ti^2 = (q - q^(-1))*Ti - q1*q2
q = self.q()
z_elt = {perm_i:q, perm:q-1}
return self._from_dict(z_elt)
def __init__(self,
dataset=None,
root_dir=None,
transform=None,
permutator=None,
n=3):
"""
Set all the necessary members.
:param root_dir: The root directory in which the images reside. (Required if dataset == None)
:param permutator: A Permutator object
:param transform: Transforms to applay to the images.
"""
if dataset is not None and not isinstance(dataset, str):
self.root_dir = dataset.root
self.data = dataset
elif (isinstance(root_dir, str) or issubclass(
type(root_dir), pathlib.Path)) and transform is not None:
self.root_dir = root_dir
self.transform = transform
self.data = datasets.ImageFolder(self.root_dir,
transform=self.transform)
else:
raise ValueError(
"JigsawTileDataset need valid dataset or root_dir and transform input."
)
if isinstance(permutator, permutation.Permutation):
self.permutator = permutator
else:
self.permutator = permutation.Permutation(number_of_tiles=n * n)
self.n = n
def __init__(self, R, n, q=None):
"""
TESTS::
sage: HeckeAlgebraSymmetricGroupT(QQ, 3)
Hecke algebra of the symmetric group of order 3 on the T basis over Univariate Polynomial Ring in q over Rational Field
::
sage: HeckeAlgebraSymmetricGroupT(QQ, 3, q=1)
Hecke algebra of the symmetric group of order 3 with q=1 on the T basis over Rational Field
"""
self.n = n
self._basis_keys = permutation.Permutations(n)
self._name = "Hecke algebra of the symmetric group of order %s"%self.n
self._one = permutation.Permutation(range(1,n+1))
if q is None:
q = PolynomialRing(R, 'q').gen()
R = q.parent()
else:
if q not in R:
raise ValueError, "q must be in R (= %s)"%R
self._name += " with q=%s"%q
self._q = q
CombinatorialAlgebra.__init__(self, R)
# _repr_ customization: output the basis element indexed by [1,2,3] as [1,2,3]
self.print_options(prefix="")
def test_permutation(self):
my_permutation = permutation.Permutation()
self.assertEqual(my_permutation.check_permutation(None, "foo"), False)
self.assertEqual(my_permutation.check_permutation("", "foo"), False)
self.assertEqual(my_permutation.check_permutation("Nib", "bin"), False)
self.assertEqual(my_permutation.check_permutation("act", "cat"), True)
self.assertEqual(my_permutation.check_permutation("a ct", "ca t"),
True)
def one_basis(self):
"""
Returns the identity of the symmetric group, as per
``AlgebrasWithBasis.ParentMethods.one_basis``
EXAMPLES::
sage: QS3 = SymmetricGroupAlgebra(QQ, 3)
sage: QS3.one_basis()
[1, 2, 3]
"""
return permutation.Permutation(range(1,self.n+1))
def __init__(self, R):
"""
EXAMPLES::
sage: X = SchubertPolynomialRing(QQ)
sage: X == loads(dumps(X))
True
"""
self._name = "Schubert polynomial ring with X basis"
self._repr_option_bracket = False
self._one = permutation.Permutation([1])
CombinatorialAlgebra.__init__(self,
R,
cc=permutation.Permutations(),
category=GradedAlgebrasWithBasis(R))
self.print_options(prefix='X')
def det_perm(self): # A.det()
a, b = self.shape
assert (a == b)
P = perm.perm(a)
s = 0
for pi in P:
pi2 = perm.Permutation(pi)
sgn = pi2.sign()
Prod = 1
for i in range(a):
j = pi2.g(i)
v = self.g(i, j)
Prod = Prod * v
v = sgn * Prod
s = s + v
return s
def t(self, i):
"""
EXAMPLES::
sage: H3 = HeckeAlgebraSymmetricGroupT(QQ,3)
sage: H3.t(1)
T[2, 1, 3]
sage: H3.t(2)
T[1, 3, 2]
sage: H3.t(0)
Traceback (most recent call last):
...
ValueError: i must be between 1 and n-1 (= 2)
"""
if i not in range(1, self.n):
raise ValueError, "i must be between 1 and n-1 (= %s)"%(self.n-1)
return self.monomial(self.basis().keys()(permutation.Permutation( (i, i+1) ) ))
def _element_constructor_(self, x):
"""
Coerce x into self.
EXAMPLES::
sage: X = SchubertPolynomialRing(QQ)
sage: X._element_constructor_([2,1,3])
X[2, 1]
sage: X._element_constructor_(Permutation([2,1,3]))
X[2, 1]
sage: R.<x1, x2, x3> = QQ[]
sage: X(x1^2*x2)
X[3, 2, 1]
TESTS:
We check that :trac:`12924` is fixed::
sage: X = SchubertPolynomialRing(QQ)
sage: X._element_constructor_([1,2,1])
Traceback (most recent call last):
...
ValueError: The input [1, 2, 1] is not a valid permutation
"""
if isinstance(x, list):
#checking the input to avoid symmetrica crashing Sage, see trac 12924
if not x in Permutations():
raise ValueError, "The input %s is not a valid permutation" % (
x)
perm = permutation.Permutation(x).remove_extra_fixed_points()
return self._from_dict({perm: self.base_ring()(1)})
elif isinstance(x, permutation.Permutation):
if not list(x) in Permutations():
raise ValueError, "The input %s is not a valid permutation" % (
x)
perm = x.remove_extra_fixed_points()
return self._from_dict({perm: self.base_ring()(1)})
elif is_MPolynomial(x):
return symmetrica.t_POLYNOM_SCHUBERT(x)
else:
raise TypeError
def pi_ik(itab, ktab):
"""
EXAMPLES::
sage: from sage.combinat.symmetric_group_algebra import pi_ik
sage: pi_ik([[1,3],[2]], [[1,2],[3]])
[1, 3, 2]
"""
it = Tableau(itab)
kt = Tableau(ktab)
p = [None]*kt.size()
for i in range(len(kt)):
for j in range(len(kt[i])):
p[ it[i][j] -1 ] = kt[i][j]
QSn = SymmetricGroupAlgebra(QQ, it.size())
p = permutation.Permutation(p)
return QSn(p)
print()
print("Cayley table for (Z/10Z)*")
g.create_multiplicative_group(10).cayley_table()
print()
print("Cayley table for S3")
g.create_symmetric_group(3).cayley_table()
print()
print("Cayley table for A4")
g.create_alternating_group(4).cayley_table()
print()
print("Check to see if Z/3Z and A3 are isomorphic")
print(g.create_additive_group(3) == g.create_alternating_group(3))
print()
print("Cayley tables for all proper subgroups of Z/6Z")
for h in g.create_additive_group(6).find_proper_subgroups():
h.cayley_table()
print()
print("Cayley tables for all proper subgroups of S3")
for i in g.create_symmetric_group(3).find_proper_subgroups():
i.cayley_table()
print()
start = time.time()
print("Cayley tables for all proper subgroups of A4")
for i in g.create_alternating_group(4).find_proper_subgroups():
i.cayley_table()
end = time.time()
elapsed = end - start
print("Time to perform this operation: " + str(elapsed))
print("A Cayley graph for S3")
g.create_symmetric_group(3).cayley_graph(p.Permutation([2, 1, 3]),
p.Permutation([3, 1, 2]))
def test_identity(self): iden = permutation.Permutation([0,1,2]) self.assertEqual(iden, permutation.Permutation.identity(3))
def test_mul(self): p1 = permutation.Permutation([0,2,1]) p2 = permutation.Permutation([2,0,1]) self.assertEqual(p2*p1, permutation.Permutation([1,0,2]))
import normalization as normtool
import permutation as permtool
import sqlconnection as conntool
sqlcon = conntool.SQLConnection("db/sentiment.db")
your_api_key = ""
norm = normtool.Normalization()
perm = permtool.Permutation(api_key=your_api_key,
max_meanings=3,
use_local_meanings=True)
counter_save_local_meanings = 0
while True:
progress = sqlcon.getNumberOfSamplesToExpand()
print(progress)
samplesToExpand = sqlcon.getSamplesToExpand()
if len(samplesToExpand) == 0:
break
for sample in samplesToExpand:
sampleId, message, status = sample
text = norm.transform(message)
disambiguation_set = perm.getDisambiguation(text)
meanings = perm.getMeanings(disambiguation_set)
new_samples = perm.transform(text,
def _translate_from_names(src: Mapping[str, str],
names: Mapping[str, int]) -> perm.Permutation:
num_dict = {names[k]: names[v] for k, v in src.items()}
p = [num_dict.get(i, i) for i in range(len(names))]
return perm.Permutation(p)
def pretrain_stl10(
number_of_epochs: int, experiment_description: str
) -> Tuple[nn.Sequential, logger.Experiment]:
"""
Train a jigsaw puzzle solver on the stl10 dataset
:param experiment_description: Description of the target of the experiment
:param number_of_epochs: Number of epochs to train
:return: model, logger
"""
# region Set device
torch.backends.cudnn.benchmark = True
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# endregion
n = constants.n
image_size = constants.image_size
piece_crop_percentage = constants.piece_crop_percentage
tile_size = constants.tile_size
batch_size = 128
lr = 10e-2
batch_norm = True
n_epochs = number_of_epochs
use_visdom = True
save_model = True
# region Permutator
permutator = permutation.Permutation(
filename=Path("data", "permutations_d_1000.csv"))
print("Permutator created.")
# endregion
# region Transform operations
transforms_train = transforms.Compose([
transforms.RandomHorizontalFlip(0.5),
transforms.RandomGrayscale(0.3),
preprocessing.RandomJitterColorChannels(),
transforms.RandomCrop(image_size, pad_if_needed=True),
transforms.ToTensor(),
preprocessing.CutIntoRandomTiles(
image_size=image_size,
piece_crop_percentage=piece_crop_percentage,
max_rotation_angle=0),
preprocessing.PerTileNormalize(),
preprocessing.StackTiles()
])
transforms_val = transforms.Compose([
transforms.RandomCrop(image_size, pad_if_needed=True),
transforms.ToTensor(),
preprocessing.CutIntoDeterministicTiles(
image_size=image_size,
piece_crop_percentage=piece_crop_percentage),
preprocessing.PerTileNormalize(),
preprocessing.StackTiles()
])
# endregion
# region data sets
image_path = Path("data", "stl10_images")
images_train = jigsaw_model.STL10(root=image_path,
transform=transforms_train,
split='train+unlabeled')
images_val = jigsaw_model.STL10(root=image_path,
transform=transforms_val,
split='test')
dataset_train = jigsaw_model.JigsawTileDataset(dataset=images_train,
n=n,
permutator=permutator)
dataset_val = jigsaw_model.JigsawTileDataset(dataset=images_val,
n=n,
permutator=permutator)
# endregion
# region Loaders
loader_options = {
'pin_memory': True,
'num_workers': 8,
'batch_size': batch_size
}
loader_train = torch.utils.data.DataLoader(dataset_train,
shuffle=True,
**loader_options)
loader_val = torch.utils.data.DataLoader(dataset_val,
shuffle=False,
**loader_options)
# endregion
# region model
number_of_classes = permutator.number_of_permutations
model = jigsaw_model.CFN(number_of_classes=number_of_classes,
batch_norm=batch_norm,
tile_size=tile_size,
feature_extractor=jigsaw_model.AlexNetImageNet(
batch_norm=batch_norm)).to(device)
# endregion
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters())
# region Logger
log = pipeline.logger_from_params(
use_visdom=use_visdom,
dataset=image_path,
learning_rate=lr,
number_of_epochs=n_epochs,
batch_size=batch_size,
optimizer=optimizer,
model=model,
number_of_permutations=permutator.number_of_permutations,
transforms=transforms_train,
piece_crop_percentage=piece_crop_percentage,
batch_norm=batch_norm,
train_type='pretrain')
pipeline.write_experiment_description(experiment_description, log)
# endregion
if not save_model:
print("\n--- MODEL WILL NOT BE SAVED ---\n")
for epoch in range(n_epochs):
pipeline.train(loader_train,
model,
optimizer,
device,
epoch=epoch,
criterion=criterion,
log=log)
current_accuracy = pipeline.validate(loader_val,
model,
device,
epoch=epoch,
criterion=criterion,
log=log)
if save_model:
pipeline.maybe_save_checkpoint(current_accuracy,
model,
epoch,
log=log)
else:
print("\nMODEL WILL NOT BE SAVED\n")
return model, log
