Hallo Leute,
vllcht. hat der ein oder andere meinen Post schon gelesen; ich bin dabei, eine Recommendation Engine zu entwickeln. Dabei werden große Datenmengen verwendet; es müssen die Korrelationen von 817k zu 817k Filmen berechnet werden.
Um die MovieFeature Matrix zu erstellen verwende ich folgende Funktion:
Die Funktion assign wird wie folgt benutzt:
Die Funktion private byte[][] create Array() wird wie folgt aufgerufen:
Soweit dazu. Es ergeben sich nun rießige Arrays...
Mein PC mit 8GB Arbeitsspeicher ist dafür nicht ausreichend.....
Seht ihr eine andere Möglichkeit, nicht so viel Speicher zu verbrauchen beim erstellen der Matrix? Ist irgendwo ein grober Fehler?
EDIT: Sehe gerade, dass die Kommentare noch nicht optimal sind 🙂 Bitte habt Nachsehen; die werden noch verbessert.
Gruß Fabian
vllcht. hat der ein oder andere meinen Post schon gelesen; ich bin dabei, eine Recommendation Engine zu entwickeln. Dabei werden große Datenmengen verwendet; es müssen die Korrelationen von 817k zu 817k Filmen berechnet werden.
Um die MovieFeature Matrix zu erstellen verwende ich folgende Funktion:
Java:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package main.java.math;
import java.util.ArrayList;
import main.java.ressources.PropertyReader;
/**
*
* @author Fabian
*/
public class ItemMatrixCreator {
//Variables
//All entinitys
private ArrayList<String> values = new ArrayList<>();
private int counter = 0;
//Values for the single item
private ArrayList<String> itemValue = new ArrayList<>();
private int itemCounter = 0;
PropertyReader mainconf = new PropertyReader();
/**
* Assigns on the one hand all itemValues. On the other hand, it builds a
* vector excluding all known values, so that no value exists twice.
*
* @param value String: get all values for creating the right matrix
*/
public void assign(String value) {
mainconf.getProb("conf/MainConfig.properties");
itemValue.add(itemCounter, value);
itemCounter++;
boolean known = false;
String[] valueSplit = value.split(mainconf.read("split"));
for (int x = 0; x <= valueSplit.length-1; x++) {
for (int i = 0; i <= values.size()-1; i++) {
if (values.get(i) == null ? valueSplit[x] == null : values.get(i).equals(valueSplit[x])) {
known = true;
break;
} else {
known = false;
}
}
if (known == false) {
if (!"".equals(valueSplit[x])) {
values.add(counter, valueSplit[x]);
counter++;
}
}
}
}
/**
* Creates a two-dimensional matrix for the item entinitys. For example a
* genrearray for films like this: 101001 100000 011111 .......
*
* @param value Sets the importance of the item entinity. The entinity can
* be a genre.
* @return an two-dimensional String
*/
public byte[][] fillMatrix(byte value) {
System.out.print(itemValue.size()+" "+ values.size()+"\n");
byte[][] array = new byte[itemValue.size()][values.size()];
for (int i = 0; i <= itemValue.size()-1; i++) {
String[] itemVal = itemValue.get(i).split(mainconf.read("split"));
for (int x = 0; x <= values.size()-1; x++) {
for (int y = 0; y <= (itemVal.length - 1); y++) {
if (itemVal[y] == null ? values.get(x) == null : itemVal[y].equals(values.get(x))) {
array[i][x] = value;
break;
} else {
array[i][x] = 0;
}
}
}
}
return array;
}
/**
* Returns all the entinity-values from all items excluding known once.
*
* @return ArrayList<String>
*/
public ArrayList<String> returnMatrix() {
return values;
}
/**
* Deletes the created matrix so that a new matrix with new values and
* entinitys can be created.
*/
public void deleteMatrix() {
counter = 0;
itemCounter = 0;
values.clear();
itemValue.clear();
}
}Die Funktion assign wird wie folgt benutzt:
Java:
private byte[][] createArray(String query, ArrayList<Integer> id, Statement que, String getString, byte fillmatrix, boolean integer) throws SQLException {
for (int j = 0; j < id.size(); j++) {
String q = query + "" + id.get(j);
ResultSet arr = que.executeQuery(q);
String res = "";
while (arr.next()) {
if (integer == false) {
res += arr.getString(getString) + mainconf.read("split");
} else if (integer == true) {
res += arr.getInt(getString) + mainconf.read("split");
}
}
matrix.assign(res);
System.out.print(res + "\n");
}
System.out.print("Array created\n");
byte[][] array = matrix.fillMatrix(fillmatrix);
matrix.deleteMatrix();
return array;
}Die Funktion private byte[][] create Array() wird wie folgt aufgerufen:
Java:
byte[][] genreArray = createArray(genreQ, id, query, "info", (byte) prop.readInt("genre"), false);Mein PC mit 8GB Arbeitsspeicher ist dafür nicht ausreichend.....
Seht ihr eine andere Möglichkeit, nicht so viel Speicher zu verbrauchen beim erstellen der Matrix? Ist irgendwo ein grober Fehler?
EDIT: Sehe gerade, dass die Kommentare noch nicht optimal sind 🙂 Bitte habt Nachsehen; die werden noch verbessert.
Gruß Fabian
