private List<List<String>> multiply(List<List<String>> a, List<List<String>> b) {
List<List<String>> c = new ArrayList<>();
for (int i = 0; i < a.size(); i++) {
List<String> l1 = a.get(i);
List<String> l3 = new ArrayList<>();
for (int j = 0; j < b.get(i).size(); j++) {
StringBuilder s = new StringBuilder();
for (int k = 0; k < l1.size(); k++) {
List<String> l2 = b.get(k);
s.append("(").append(l1.get(k)).append(")*(").append(l2.get(j)).append(")+");
}
s = new StringBuilder(StringUtils.left(s.toString(), s.length() - 1));
l3.add(s.toString());
}
c.add(l3);
}
return c;
}
private void printMat(String c, List<List<String>> m) {
System.out.println(c + ":");
for (List<String> list : m) {
System.out.print("( ");
for (String string : list) {
System.out.print(string + " ");
}
System.out.println(")");
}
}
private void printAndSolveMat(String name, List<List<String>> m) {
System.out.println(name + ":");
for (List<String> list : m) {
System.out.print("( ");
for (String string : list) {
System.out.print(string + " ");
}
System.out.println(")");
}
System.out.println(name + ":");
for (List<String> list : m) {
System.out.print("( ");
for (String string : list) {
Node o = Compiler.compile(string);
System.out.print(o.simplify().beautify() + " ");
}
System.out.println(")");
}
System.out.println(name + ":");
for (List<String> list : m) {
System.out.print("( ");
for (String string : list) {
Node o = Compiler.compile(string);
System.out.print(o.simplify().beautify().val() + " ");
}
System.out.println(")");
}
}
Jo. Ist heftig. Brauche viel Zeit und Geduld.
Wie ich schon sagte, die Vorschläge taugen nix.
Das ist nicht dein Ernst? Solch ein Code sollte nicht existieren, nicht einmal wenn es drum geht, wie man das theoretisch machen könnte...
Bist du dumm oder hast du #16 von mir gar nicht gelesen?
Es gibt an sich keins, insofern man weiß, was man wie tut.
Ja, das stimmt schon. Wobei man für einiges leider dann doch noch die JNI Brücke einsetzen muss, wenn es um high Performance geht. 🙁
DL4J mit der ursprünglich erwähnten Matritzen-Bibliothek Nd4J sehen auch gut aus.
dependencies {
// Logging...
implementation "org.apache.logging.log4j:log4j-core:$log4jVers"
implementation "org.apache.logging.log4j:log4j-plugins:$log4jVers"
implementation "org.apache.logging.log4j:log4j-config-properties:$log4jVers"
implementation 'org.slf4j:slf4j-simple:2.1.0-alpha1'
// Die Deeplearning4j Kernbibliothek
implementation 'org.deeplearning4j:deeplearning4j-core:1.0.0-M2.1'
// Das CPU-Backend für die mathematischen Berechnungen (ND4J)
implementation 'org.nd4j:nd4j-native:1.0.0-M2.1'
// Plattform-spezifische Binärdateien für das CPU-Backend (automatische Erkennung)
implementation 'org.nd4j:nd4j-native-platform:1.0.0-M2.1'
}
jar.enabled = false
tasks.named('distZip').configure { enabled = false }
tasks.named('distTar').configure { enabled = false }
tasks.named('startScripts').configure { enabled = false }
tasks.shadowJar {
setProperty("zip64", true)
duplicatesStrategy = DuplicatesStrategy.INCLUDE
mergeServiceFiles()
}Hallo,
Idee: Wenn es erstmal nur um die API geht und die Laufzeit keine Rolle spielt, sollte die auch ein LLM relativ leicht alles generieren können. Also quasi die Java-Sicht auf NumPy. Der Vorteil wäre, dass du selbst etwas über die Implementierung von Algorithmen lernst -- wenn dich das interessiert. Es wäre auch interessant aus Sicht eines API-Designers, weil NumPy überladene Operatoren verwendet, die Java ja natürlich so nicht hat. Also müsste so was intelligent nachgebildet werden. Logischerweise nur als Lernprojekt sehen. Produktiv wäre das sicherlich keine gute Idee; die modernen Bibliotheken nutzen alle SIMD oder sogar die GPU auf der Hardware-Seite und können dadurch Berechnungen vielfach beschleunigen.
interface ActivationFunction {
float forward(float input);
float derivative(float input);
}public class ReLUActivation implements ActivationFunction {
@Override
public float forward(float input) { return input < 0 ? 0 : input; }
@Override
public float derivative(float input) { return input > 0 ? 1 : 0; }
}interface Layer {
float[] forward(float[] inputs);
int getOutputSize();
}public class DenseLayer implements Layer {
private final int inputSize;
private final int outputSize;
private final ActivationFunction activation;
private float[] weights;
private float[] bias;
public DenseLayer(int inputSize, int outputSize, ActivationFunction activation) {
this.inputSize = inputSize;
this.outputSize = outputSize;
this.activation = activation;
weights = new float[inputSize * outputSize];
bias = new float[outputSize];
Random random = new Random();
for (int i = 0; i < weights.length; i++) {
weights[i] = (float) random.nextGaussian();
}
}
// für Tests und das Laden aus Dateien...
public DenseLayer(float[] weights, float[] bias, ActivationFunction activation) {
this.inputSize = weights.length / bias.length;
this.outputSize = bias.length;
this.activation = activation;
this.weights = weights;
this.bias = bias;
}
@Override
public float[] forward(float[] inputs) {
float[] output = new float[outputSize];
int w = 0;
for (int i = 0; i < output.length; i++) {
float sum = bias[i];
for (int j = 0; j < inputs.length; j++) {
sum += weights[w] * inputs[j];
w++;
}
output[i] = activation.forward(sum);
}
return output;
}
@Override
public int getOutputSize() { return outputSize; }
}public class NeuralNetwork {
private final List<Layer> layers = new ArrayList<>();
private final int inputSize;
public NeuralNetwork(int inputSize) {
this.inputSize = inputSize;
}
public void addDenseLayer(int neurons, ActivationFunction activation) {
int layerInputs = layers.isEmpty() ? inputSize : layers.getLast().getOutputSize();
layers.add(new DenseLayer(layerInputs, neurons, activation));
}
public float[] forward(float[] inputs) {
if (inputs.length != inputSize) throw new IllegalArgumentException();
float[] output = inputs;
for (Layer layer : layers) {
output = layer.forward(output);
}
return output;
}
}Adam wäre als Updater besser
Xavier wäre als Randomizer besser
double wäre für die Weights besser
Zum Beispiel Quadratic oder Hellinger
Zum Beispiel Cross entropy
Dann wäre es schnell
Warum bezweifelst Du das? Du kannst ja heute auch noch 16-Bit-Additionen auf den 64-Bit-Registern durchführen und wenn Du willst, steckst Du in ein 64-Bit-Register z. B. zwei 31-Bit-Werte rein und führst mit einer 64-Bit-Addition eben zwei 32-Bit-Additionen auf einmal durch. Und die Intel Befehlssätze für SIMD können zusätzlich auch noch FP16.
Lass uns einfach mal die KI Fragen:
Google KI hat gesagt.:
