public void learn_precomputed()
{
#region doc_precomputed
// As an example, we will try to learn a decision machine
// that can replicate the "exclusive-or" logical function:
double[][] inputs =
{
new double[] { 0, 0 }, // the XOR function takes two booleans
new double[] { 0, 1 }, // and computes their exclusive or: the
new double[] { 1, 0 }, // output is true only if the two booleans
new double[] { 1, 1 } // are different
};
int[] xor = // this is the output of the xor function
{
0, // 0 xor 0 = 0 (inputs are equal)
1, // 0 xor 1 = 1 (inputs are different)
1, // 1 xor 0 = 1 (inputs are different)
0, // 1 xor 1 = 0 (inputs are equal)
};
// Let's use a Gaussian kernel
var kernel = new Gaussian(0.1);
// Create a pre-computed Gaussian kernel matrix
var precomputed = new Precomputed(kernel.ToJagged(inputs));
// Now, we can create the sequential minimal optimization teacher
var learn = new SequentialMinimalOptimization <Precomputed, int>()
{
Kernel = precomputed // set the precomputed kernel we created
};
// And then we can obtain the SVM by using Learn
var svm = learn.Learn(precomputed.Indices, xor);
// Finally, we can obtain the decisions predicted by the machine:
bool[] prediction = svm.Decide(precomputed.Indices);
// We can also compute the machine prediction to new samples
double[][] sample =
{
new double[] { 0, 1 }
};
// Update the precomputed kernel with the new samples
precomputed = new Precomputed(kernel.ToJagged2(inputs, sample));
// Update the SVM kernel
svm.Kernel = precomputed;
// Compute the predictions to the new samples
bool[] newPrediction = svm.Decide(precomputed.Indices);
#endregion
Assert.AreEqual(prediction, Classes.Decide(xor));
Assert.AreEqual(newPrediction.Length, 1);
Assert.AreEqual(newPrediction[0], true);
}
private static Precomputed FlippedMillerLoopDoubling(BN128G2 g2)
{
Fp2 x = g2.x, y = g2.y, z = g2.z;
Fp2 a = Fp._2_INV.Mul(x.Mul(y)); // a = x * y / 2
Fp2 b = y.Squared(); // b = y^2
Fp2 c = z.Squared(); // c = z^2
Fp2 d = c.Add(c).Add(c); // d = 3 * c
Fp2 e = Parameters.B_Fp2.Mul(d); // e = twist_b * d
Fp2 f = e.Add(e).Add(e); // f = 3 * e
Fp2 g = Fp._2_INV.Mul(b.Add(f)); // g = (b + f) / 2
Fp2 h = y.Add(z).Squared().Sub(b.Add(c)); // h = (y + z)^2 - (b + c)
Fp2 i = e.Sub(b); // i = e - b
Fp2 j = x.Squared(); // j = x^2
Fp2 e2 = e.Squared(); // e2 = e^2
Fp2 rx = a.Mul(b.Sub(f)); // rx = a * (b - f)
Fp2 ry = g.Squared().Sub(e2.Add(e2).Add(e2)); // ry = g^2 - 3 * e^2
Fp2 rz = b.Mul(h); // rz = b * h
Fp2 ell0 = Parameters.TWIST.Mul(i); // ell_0 = twist * i
Fp2 ellVW = h.Negate(); // ell_VW = -h
Fp2 ellVV = j.Add(j).Add(j); // ell_VV = 3 * j
return(Precomputed.Of(
new BN128G2(rx, ry, rz),
new EllCoeffs(ell0, ellVW, ellVV)
));
}
private static Precomputed FlippedMillerLoopMixedAddition(BN128G2 base_val, BN128G2 addend)
{
Fp2 x1 = addend.x, y1 = addend.y, z1 = addend.z;
Fp2 x2 = base_val.x, y2 = base_val.y;
Fp2 d = x1.Sub(x2.Mul(z1)); // d = x1 - x2 * z1
Fp2 e = y1.Sub(y2.Mul(z1)); // e = y1 - y2 * z1
Fp2 f = d.Squared(); // f = d^2
Fp2 g = e.Squared(); // g = e^2
Fp2 h = d.Mul(f); // h = d * f
Fp2 i = x1.Mul(f); // i = x1 * f
Fp2 j = h.Add(z1.Mul(g)).Sub(i.Dbl()); // j = h + z1 * g - 2 * i
Fp2 x3 = d.Mul(j); // x3 = d * j
Fp2 y3 = e.Mul(i.Sub(j)).Sub(h.Mul(y1)); // y3 = e * (i - j) - h * y1)
Fp2 z3 = z1.Mul(h); // z3 = Z1*H
Fp2 ell0 = Parameters.TWIST.Mul(e.Mul(x2).Sub(d.Mul(y2))); // ell_0 = TWIST * (e * x2 - d * y2)
Fp2 ellVV = e.Negate(); // ell_VV = -e
Fp2 ellVW = d; // ell_VW = d
return(Precomputed.Of(
new BN128G2(x3, y3, z3),
new EllCoeffs(ell0, ellVW, ellVV)
));
}
public void SetLineOnPath(int line, int from, int to, double s, double t)
{
var lineObj = GetManagedObject(line, "SetLineOnPath.Line");
var lr = lineObj.GetComponent <LineRenderer>();
var points = Precomputed.GetLinePath(from, to, s, t);
lr.SetWidth(GetNoteScale(s), GetNoteScale(t));
lr.SetVertexCount(points.Length);
lr.SetPositions(points);
if (SceneSettings.Hidden)
{
lr.material.color = new Color(1, 1, 1, 1 - (float)s);
}
}
private void GenerateElGamal(Stream outSecret, Stream outPublic)
{
// Prepare a strong Secure Random with seed
SecureRandom secureRandom = PgpEncryptionUtil.GetSecureRandom();
IAsymmetricCipherKeyPairGenerator dsaKpg = GeneratorUtilities.GetKeyPairGenerator("DSA");
DsaParametersGenerator pGen = new DsaParametersGenerator();
pGen.Init((int)PublicKeyLength.BITS_1024, 80, new SecureRandom()); // DSA is 1024 even for long 2048+ ElGamal keys
DsaParameters dsaParams = pGen.GenerateParameters();
DsaKeyGenerationParameters kgp = new DsaKeyGenerationParameters(secureRandom, dsaParams);
dsaKpg.Init(kgp);
//
// this takes a while as the key generator has to Generate some DSA parameters
// before it Generates the key.
//
AsymmetricCipherKeyPair dsaKp = dsaKpg.GenerateKeyPair();
IAsymmetricCipherKeyPairGenerator elgKpg = GeneratorUtilities.GetKeyPairGenerator("ELGAMAL");
Group elgamalGroup = Precomputed.GetElGamalGroup((int)this.publicKeyLength);
if (elgamalGroup == null)
{
throw new ArgumentException("ElGamal Group not found for key length: " + this.publicKeyLength);
}
Org.BouncyCastle.Math.BigInteger p = elgamalGroup.GetP();
Org.BouncyCastle.Math.BigInteger g = elgamalGroup.GetG();
secureRandom = PgpEncryptionUtil.GetSecureRandom();
ElGamalParameters elParams = new ElGamalParameters(p, g);
ElGamalKeyGenerationParameters elKgp = new ElGamalKeyGenerationParameters(secureRandom, elParams);
elgKpg.Init(elKgp);
//
// this is quicker because we are using preGenerated parameters.
//
AsymmetricCipherKeyPair elgKp = elgKpg.GenerateKeyPair();
DsaElGamalKeyGeneratorUtil.ExportKeyPair(outSecret, outPublic, dsaKp, elgKp, identity, passphrase, true);
}
private static List <EllCoeffs> CalcEllCoeffs(Bn128Fp2 baseElement)
{
List <EllCoeffs> coeffs = new List <EllCoeffs>();
Bn128Fp2 addend = baseElement;
// for each bit except most significant one
for (int i = LoopCount.BitLength() - 2; i >= 0; i--)
{
Precomputed doubling = FlippedMillerLoopDoubling(addend);
addend = doubling.G2;
coeffs.Add(doubling.Coeffs);
if (LoopCount.TestBit(i))
{
Precomputed additionInLoop = FlippedMillerLoopMixedAddition(baseElement, addend);
addend = additionInLoop.G2;
coeffs.Add(additionInLoop.Coeffs);
}
}
Bn128Fp2 q1 = baseElement.MulByP();
Bn128Fp2 q2 = q1.MulByP();
q2 = new Bn128Fp2(q2.X, q2.Y.Negate(), q2.Z); // q2.y = -q2.y
Precomputed addition = FlippedMillerLoopMixedAddition(q1, addend);
addend = addition.G2;
coeffs.Add(addition.Coeffs);
addition = FlippedMillerLoopMixedAddition(q2, addend);
coeffs.Add(addition.Coeffs);
return(coeffs);
}
private static List <EllCoeffs> CalcEllCoeffs(BN128G2 base_val)
{
List <EllCoeffs> coeffs = new List <EllCoeffs>();
BN128G2 addend = base_val;
Precomputed addition;
// for each bit except most significant one
for (int i = LOOP_COUNT.BitLength - 2; i >= 0; i--)
{
Precomputed doubling = FlippedMillerLoopDoubling(addend);
addend = doubling.g2;
coeffs.Add(doubling.coeffs);
if (LOOP_COUNT.TestBit(i))
{
addition = FlippedMillerLoopMixedAddition(base_val, addend);
addend = addition.g2;
coeffs.Add(addition.coeffs);
}
}
BN128G2 q1 = base_val.MulByP();
BN128G2 q2 = q1.MulByP();
q2 = new BN128G2(q2.x, q2.y.Negate(), q2.z); // q2.y = -q2.y
addition = FlippedMillerLoopMixedAddition(q1, addend);
addend = addition.g2;
coeffs.Add(addition.coeffs);
addition = FlippedMillerLoopMixedAddition(q2, addend);
coeffs.Add(addition.coeffs);
return(coeffs);
}
private void PrecomputedAttack(BitArray[] plainTextArray, BitArray[] cipherTextArray)
{
var KeyList = Precomputed.Attack(plainTextArray, cipherTextArray);
StringBuilder sB = new StringBuilder("Keys found: ");
foreach (var key in KeyList)
{
sB.Append(key);
sB.Append(", ");
}
sB.Remove(sB.Length - 2, 2);
Console.WriteLine(sB.ToString());
var goodKeys = Bruteforce.KeysForAll(KeyList, plainTextArray, cipherTextArray);
sB.Clear();
sB.Append("Keys that work for all the pairs: ");
foreach (var key in goodKeys)
{
sB.Append(key);
sB.Append(", ");
}
sB.Remove(sB.Length - 2, 2);
Console.WriteLine(sB.ToString());
}
public void multiclass_precomputed_matrix_smo()
{
#region doc_precomputed
// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
//
double[][] trainInputs =
{
// input output
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 1, 0 }, // 0
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
new double[] { 1, 0, 1, 1 }, // 2
new double[] { 1, 1, 0, 1 }, // 2
new double[] { 0, 1, 1, 1 }, // 2
new double[] { 1, 1, 1, 1 }, // 2
};
int[] trainOutputs = // those are the training set class labels
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// Let's chose a kernel function
Polynomial kernel = new Polynomial(2);
// Get the kernel matrix for the training set
double[][] K = kernel.ToJagged(trainInputs);
// Create a pre-computed kernel
var pre = new Precomputed(K);
// Create a one-vs-one learning algorithm using SMO
var teacher = new MulticlassSupportVectorLearning <Precomputed, int>()
{
Learner = (p) => new SequentialMinimalOptimization <Precomputed, int>()
{
Kernel = pre
}
};
#if DEBUG
teacher.ParallelOptions.MaxDegreeOfParallelism = 1;
#endif
// Learn a machine
var machine = teacher.Learn(pre.Indices, trainOutputs);
// Compute the machine's prediction for the training set
int[] trainPrediction = machine.Decide(pre.Indices);
// Evaluate prediction error for the training set using mean accuracy (mAcc)
double trainingError = new ZeroOneLoss(trainOutputs).Loss(trainPrediction);
// Now let's compute the machine's prediction for a test set
double[][] testInputs = // test-set inputs
{
// input output
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
};
int[] testOutputs = // those are the test set class labels
{
0, 0, 1, 2,
};
// Compute precomputed matrix between train and testing
pre.Values = kernel.ToJagged2(trainInputs, testInputs);
// Update the kernel
machine.Kernel = pre;
// Compute the machine's prediction for the test set
int[] testPrediction = machine.Decide(pre.Indices);
// Evaluate prediction error for the training set using mean accuracy (mAcc)
double testError = new ZeroOneLoss(testOutputs).Loss(testPrediction);
#endregion
Assert.AreEqual(0, trainingError);
Assert.AreEqual(0, testError);
// Create a one-vs-one learning algorithm using SMO
var teacher2 = new MulticlassSupportVectorLearning <Polynomial>()
{
Learner = (p) => new SequentialMinimalOptimization <Polynomial>()
{
Kernel = kernel
}
};
#if DEBUG
teacher.ParallelOptions.MaxDegreeOfParallelism = 1;
#endif
// Learn a machine
var expected = teacher2.Learn(trainInputs, trainOutputs);
Assert.AreEqual(4, expected.NumberOfInputs);
Assert.AreEqual(3, expected.NumberOfOutputs);
Assert.AreEqual(0, machine.NumberOfInputs);
Assert.AreEqual(3, machine.NumberOfOutputs);
var machines = Enumerable.Zip(machine, expected, (a, b) => Tuple.Create(a.Value, b.Value));
foreach (var pair in machines)
{
var a = pair.Item1;
var e = pair.Item2;
Assert.AreEqual(0, a.NumberOfInputs);
Assert.AreEqual(2, a.NumberOfOutputs);
Assert.AreEqual(4, e.NumberOfInputs);
Assert.AreEqual(2, e.NumberOfOutputs);
Assert.IsTrue(a.Weights.IsEqual(e.Weights));
}
}
