Skip to content

GitLab

P
Predictive Analytics New
Commit 59c96ccb authored by Jens Plüddemann's avatar Jens Plüddemann
Browse files
Options

refactoring

parent c6bf8708
Hide whitespace changes
Inline Side-by-side
Showing with 306 additions and 277 deletions
src/deep_learning/main.py
View file @ 59c96ccb
......@@ -3,10 +3,7 @@ import random
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from keras import layers
from keras import models
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
class DeepLearning:
......@@ -117,283 +114,10 @@ class DeepLearning:
plt.show()
def generate_rectangle_test_data(self):
# Setze Parameter
p_start = 0.3
p = p_start
damping = 1.3
epsilon = 0.01
epsilon_err = 0.3
n = 500
d = [1, 1, 1, 2, 1, 3, 2, 3, 2, 2, 2, 1]
# initialisiere eine leere Liste für das Ergebnis
result = []
# für jede Zahl von 0 bis 500
for i in range(n):
# erstelle eine Kopie des
d2 = d.copy()
# Wenn der Rest von i / 10 = 0 ist ,dann setze p auf 0.3
if i % 10 == 0:
p = p_start
# Selektiere einen zufälligen Wert aus der Liste
bend = random.choice([0, 2, 4, 6, 8, 10])
# Wenn ein zufälliger Wert zwischen 0 und 1 kleiner gleich p ist
if random.random() <= p:
# setze nv auf den Wert von d2 an der Stelle bend +
# einen zufälligen Wert aus einer Normalverteilung (epsilon_err)
# (erster Parameter ist Mittelwert, zweiter ist Standardabweichung)
nv = d2[bend] + random.gauss(0, epsilon_err)
# setze den Wert von d2 an der Stelle bend auf nv
d2[bend] = nv
# erstelle eine neue Liste mit einigen festen Werten und i und p
# Quick and Dirty.... muss nicht schlecht sein
more = [i, 3, 4, 10, p, 0, 1]
# setze die Liste d2 neu zusammen aus d2 und der more Liste (konkatenieren)
d2 = d2 + more
# Wenn die Zufallszahl größer als p ist
else:
# einen zufälligen Wert aus einer Normalverteilung (epsilon)
# (erster Parameter ist Mittelwert, zweiter ist Standardabweichung)
nv = d2[bend] + random.gauss(0, epsilon)
# setze den Wert von d2 an der Stelle bend auf nv
d2[bend] = nv
# erstelle eine neue Liste mit einigen festen Werten und i und p
# Quick and Dirty... muss nicht schlecht sein
more = [i, 1, 2, 5, p, 1, 0]
# setze die Liste d2 neu zusammen aus d2 und der more Liste (konkatenieren)
d2 = d2 + more
# füge d2 der Ergebnisliste hinzu
result.append(d2)
# setze p auf p * damping
p *= damping
# erstelle ein neues Dataframe aus dem Ergebnis
df = pd.DataFrame(result)
# benenne die Spalten im Dataframe
df.columns = ['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4', 'x5', 'y5', 'x6', 'y6', 'i', 'p1', 'p2', 'p3',
'p', 'good', 'bad']
# speichere die erstellten Daten in eine csv Datei
df.to_csv('../../res/testdataset.csv')
# erstellen eines Plots mit 5 Zeilen und 10 Spalten
fig, axs = plt.subplots(nrows=5, ncols=10, figsize=(9, 6))
i = 0
# für jeden Wert im Ergebnis und einer eindimensionalen Liste der Werte des Plots
for v, ax in zip(result, axs.flat):
# erstellen von x und y Werten für jedes Rechteck
x = [v[0], v[2], v[4], v[6], v[8], v[10]]
y = [v[1], v[3], v[5], v[7], v[9], v[11]]
# fülle den Plot zwischen den den x und y Werten
ax.fill(x, y)
# erhöhe i um 1
i += 1
# Zeige den Plot
plt.show()
return df
def rectangles_x(self, file="../../res/data.csv"):
np.random.seed(0)
data = pd.DataFrame(
columns=['x1', 'y1', 'x1_rotated', 'y1_rotated', 'x2', 'y2', 'x2_rotated', 'y2_rotated', 'x3', 'y3',
'x3_rotated', 'y3_rotated', 'x4', 'y4', 'x4_rotated', 'y4_rotated'])
data = pd.read_csv(file, encoding='utf8', header=0, sep=';')
# erstelle die x_train Trainingsdatenrohlinge aus den jeweiligen Spaltennamen
x_train = data[['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']]
x_train = x_train.astype('int64').to_numpy()
# erstelle y_train Trainingsdatenrohlinge aus den jeweiligen Spaltennamen
y_train = data[
['x1_rotated', 'y1_rotated', 'x2_rotated', 'y2_rotated', 'x3_rotated', 'y3_rotated', 'x4_rotated',
'y4_rotated']]
y_train = y_train.astype('int64').to_numpy()
# erstelle Trainings und Testdaten
train_features, test_features, train_target, test_target = train_test_split(x_train, y_train, test_size=0.1,
random_state=0)
# erstellen des neuronalen Netzwerks
network = models.Sequential()
# füge die Daten dem Netz hinzu mit der Aktivierungsfunktion ReLu
network.add(layers.Dense(units=50, activation='relu', input_shape=(train_features.shape[1],)))
# füge eine Ebene ohne Aktivierungsfunktion hinzu
network.add(layers.Dense(units=8))
# Berechne das Netzwerk
network.compile(loss='mse', optimizer='RMSprop', metrics=['mse'])
# Trainiere das Netzwerk
history = network.fit(train_features, train_target, epochs=5, verbose=1, batch_size=100,
validation_data=(test_features, test_target))
# Prediction
print(
'Correct rotation of the square with the points (x&y): 1&9, 3&9, 3&11, 1&11: [[ -9 1 -9 3 -11 3 -11 1]]')
print('Prediction for the square with the corner points: 1&9, 3&9, 3&11, 1&11: ',
network.predict(np.array([[1, 9, 3, 9, 3, 11, 1, 11]]), verbose=0))
# erhalten des Ergebnisses der Vorhersage des Netzwerks
result = network.predict(np.array([[1, 9, 3, 9, 3, 12, 1, 12]]), verbose=0)
# erstelle 2 Listen
x1, y1 = [], []
# für jeden Wert von 0 bis zur länge der ersten Liste des Ergebnisses
for i in range(len(result[0])):
# Wenn der Rest von i / 2 = 0 ist
if i % 2 == 0:
# füge x1 den i-ten Wert von der ersten Liste des Ergebnisses hinzu
x1.append(result[0][i])
# Wenn der Rest von i / 2 nicht gleich 0 ist
else:
# füge y1 den i-ten Wert von der ersten Liste des Ergebnisses hinzu
y1.append(result[0][i])
# definiere x und y
x = [1, 3, 3, 1]
y = [9, 9, 12, 12]
# erstelle Plots
fig, ax = plt.subplots()
# Fülle die Fläche zwischen den x und y Werten
ax.fill(x, y)
# Fülle die Fläche zwischen den x1 und y1 Werten
ax.fill(x1, y1)
# Zeige das Plot
plt.show()
def _make2ColArray(self, x):
res = []
for row in x:
res.append([row[0], row[1]])
res.append([row[2], row[3]])
res.append([row[4], row[5]])
res.append([row[6], row[7]])
return res
def _predictAndPlot(self, p_predict, network):
q_predict = []
q_predict.append(network.predict(np.array(p_predict), verbose=0))
for item in p_predict:
plt.plot(item[0], item[1], 'bo')
for x in q_predict:
for item in x:
plt.plot(item[0], item[1], 'ro')
plt.show()
def _createModel(self, numberOfNeurons, numberOfEpochs=5, file="../../res/data.csv"):
np.random.seed(0)
### Input Data
# data = pd.DataFrame(columns=['x1','y1','x1_rotated','y1_rotated','x2','y2','x2_rotated','y2_rotated','x3','y3','x3_rotated','y3_rotated','x4','y4','x4_rotated','y4_rotated'])
data = pd.read_csv(file, encoding='utf8', header=0, sep=';')
x_train_hlp = data[['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']].values
x_train = self._make2ColArray(x_train_hlp)
print(x_train[0])
### Target Data
y_train_hlp = data[
['x1_rotated', 'y1_rotated', 'x2_rotated', 'y2_rotated', 'x3_rotated', 'y3_rotated', 'x4_rotated',
'y4_rotated']].values
y_train = self._make2ColArray(y_train_hlp)
print(y_train[0])
# Split data
train_features, test_features, train_target, test_target = train_test_split(x_train, y_train, test_size=0.1,
random_state=0)
# Convert to numpy arrays
train_features = np.array(train_features)
test_features = np.array(test_features)
train_target = np.array(train_target)
test_target = np.array(test_target)
# Print
print('train_data_shape: ', np.shape(train_features))
print('train_features example: ', train_features[0])
print('train_target example: ', train_target[0])
print('test_data_shape: ', np.shape(test_features))
# Define neural network
network = models.Sequential()
# Add fully connected layer with a ReLU activation function
network.add(layers.Dense(units=numberOfNeurons, activation='relu', input_shape=(np.shape(train_features)[1],)))
# Add fully connected layer with no activation function
network.add(layers.Dense(units=2))
# Show architecture of model
network.summary()
# Compile neural network
network.compile(loss='mse', optimizer='RMSprop',
metrics=['mse']) # Mean squared error # Optimization algorithm # Mean squared error
# Train neural network
network.fit(train_features, train_target, epochs=numberOfEpochs, verbose=1, batch_size=100,
validation_data=(test_features, test_target))
loss = network.evaluate(test_features, test_target)[0]
return network, loss
def rectangles_2(self):
# erstelle das Netzwerk
network = self._createModel(8)[0]
# erstelle eine Liste an Listen mit Werten zum Vorhersagen
p_predict = [[1, 9], [1, 11], [4, 9], [4, 11]]
# erstelle die Vorhersage und plotte das Ergebnis
self._predictAndPlot(p_predict, network)
if __name__ == '__main__':
data = DeepLearning()
# data.linear_regression()
# data.linear_regression_ml()
# data.linear_regression_sci_kit()
# data.plot_3d_curve()
# data.generate_rectangle_test_data()
# data.rectangles_x()
data.rectangles_2()
data.plot_3d_curve()
src/rectangles_2/main.py 0 → 100644
View file @ 59c96ccb
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from keras import models, layers
from sklearn.model_selection import train_test_split
class Rectangles2:
def __init__(self):
pass
def _make2ColArray(self, x):
res = []
for row in x:
res.append([row[0], row[1]])
res.append([row[2], row[3]])
res.append([row[4], row[5]])
res.append([row[6], row[7]])
return res
def _predictAndPlot(self, p_predict, network):
q_predict = []
q_predict.append(network.predict(np.array(p_predict), verbose=0))
for item in p_predict:
plt.plot(item[0], item[1], 'bo')
for x in q_predict:
for item in x:
plt.plot(item[0], item[1], 'ro')
plt.show()
def _createModel(self, numberOfNeurons, numberOfEpochs=5, file="../../res/data.csv"):
np.random.seed(0)
### Input Data
# data = pd.DataFrame(columns=['x1','y1','x1_rotated','y1_rotated','x2','y2','x2_rotated','y2_rotated','x3','y3','x3_rotated','y3_rotated','x4','y4','x4_rotated','y4_rotated'])
data = pd.read_csv(file, encoding='utf8', header=0, sep=';')
x_train_hlp = data[['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']].values
x_train = self._make2ColArray(x_train_hlp)
print(x_train[0])
### Target Data
y_train_hlp = data[
['x1_rotated', 'y1_rotated', 'x2_rotated', 'y2_rotated', 'x3_rotated', 'y3_rotated', 'x4_rotated',
'y4_rotated']].values
y_train = self._make2ColArray(y_train_hlp)
print(y_train[0])
# Split data
train_features, test_features, train_target, test_target = train_test_split(x_train, y_train, test_size=0.1,
random_state=0)
# Convert to numpy arrays
train_features = np.array(train_features)
test_features = np.array(test_features)
train_target = np.array(train_target)
test_target = np.array(test_target)
# Print
print('train_data_shape: ', np.shape(train_features))
print('train_features example: ', train_features[0])
print('train_target example: ', train_target[0])
print('test_data_shape: ', np.shape(test_features))
# Define neural network
network = models.Sequential()
# Add fully connected layer with a ReLU activation function
network.add(layers.Dense(units=numberOfNeurons, activation='relu', input_shape=(np.shape(train_features)[1],)))
# Add fully connected layer with no activation function
network.add(layers.Dense(units=2))
# Show architecture of model
network.summary()
# Compile neural network
network.compile(loss='mse', optimizer='RMSprop',
metrics=['mse']) # Mean squared error # Optimization algorithm # Mean squared error
# Train neural network
network.fit(train_features, train_target, epochs=numberOfEpochs, verbose=1, batch_size=100,
validation_data=(test_features, test_target))
loss = network.evaluate(test_features, test_target)[0]
return network, loss
def rectangles_2(self):
# erstelle das Netzwerk
network = self._createModel(8)[0]
# erstelle eine Liste an Listen mit Werten zum Vorhersagen
p_predict = [[1, 9], [1, 11], [4, 9], [4, 11]]
# erstelle die Vorhersage und plotte das Ergebnis
self._predictAndPlot(p_predict, network)
if __name__ == "__main__":
data = Rectangles2()
data.rectangles_2()
src/rectangles_x/main.py 0 → 100644
View file @ 59c96ccb
import random
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from keras import layers
from keras import models
from sklearn.model_selection import train_test_split
class RectangleX:
def __init__(self):
pass
def generate_test_data(self):
# Setze Parameter
p_start = 0.3
p = p_start
damping = 1.3
epsilon = 0.01
epsilon_err = 0.3
n = 500
d = [1, 1, 1, 2, 1, 3, 2, 3, 2, 2, 2, 1]
# initialisiere eine leere Liste für das Ergebnis
result = []
# für jede Zahl von 0 bis 500
for i in range(n):
# erstelle eine Kopie des
d2 = d.copy()
# Wenn der Rest von i / 10 = 0 ist ,dann setze p auf 0.3
if i % 10 == 0:
p = p_start
# Selektiere einen zufälligen Wert aus der Liste
bend = random.choice([0, 2, 4, 6, 8, 10])
# Wenn ein zufälliger Wert zwischen 0 und 1 kleiner gleich p ist
if random.random() <= p:
# setze nv auf den Wert von d2 an der Stelle bend +
# einen zufälligen Wert aus einer Normalverteilung (epsilon_err)
# (erster Parameter ist Mittelwert, zweiter ist Standardabweichung)
nv = d2[bend] + random.gauss(0, epsilon_err)
# setze den Wert von d2 an der Stelle bend auf nv
d2[bend] = nv
# erstelle eine neue Liste mit einigen festen Werten und i und p
# Quick and Dirty.... muss nicht schlecht sein
more = [i, 3, 4, 10, p, 0, 1]
# setze die Liste d2 neu zusammen aus d2 und der more Liste (konkatenieren)
d2 = d2 + more
# Wenn die Zufallszahl größer als p ist
else:
# einen zufälligen Wert aus einer Normalverteilung (epsilon)
# (erster Parameter ist Mittelwert, zweiter ist Standardabweichung)
nv = d2[bend] + random.gauss(0, epsilon)
# setze den Wert von d2 an der Stelle bend auf nv
d2[bend] = nv
# erstelle eine neue Liste mit einigen festen Werten und i und p
# Quick and Dirty... muss nicht schlecht sein
more = [i, 1, 2, 5, p, 1, 0]
# setze die Liste d2 neu zusammen aus d2 und der more Liste (konkatenieren)
d2 = d2 + more
# füge d2 der Ergebnisliste hinzu
result.append(d2)
# setze p auf p * damping
p *= damping
# erstelle ein neues Dataframe aus dem Ergebnis
df = pd.DataFrame(result)
# benenne die Spalten im Dataframe
df.columns = ['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4', 'x5', 'y5', 'x6', 'y6', 'i', 'p1', 'p2', 'p3',
'p', 'good', 'bad']
# speichere die erstellten Daten in eine csv Datei
df.to_csv('../../res/testdataset.csv')
# erstellen eines Plots mit 5 Zeilen und 10 Spalten
fig, axs = plt.subplots(nrows=5, ncols=10, figsize=(9, 6))
i = 0
# für jeden Wert im Ergebnis und einer eindimensionalen Liste der Werte des Plots
for v, ax in zip(result, axs.flat):
# erstellen von x und y Werten für jedes Rechteck
x = [v[0], v[2], v[4], v[6], v[8], v[10]]
y = [v[1], v[3], v[5], v[7], v[9], v[11]]
# fülle den Plot zwischen den den x und y Werten
ax.fill(x, y)
# erhöhe i um 1
i += 1
# Zeige den Plot
plt.show()
return df
def rectangles_x(self, file="../../res/data.csv"):
np.random.seed(0)
data = pd.DataFrame(
columns=['x1', 'y1', 'x1_rotated', 'y1_rotated', 'x2', 'y2', 'x2_rotated', 'y2_rotated', 'x3', 'y3',
'x3_rotated', 'y3_rotated', 'x4', 'y4', 'x4_rotated', 'y4_rotated'])
data = pd.read_csv(file, encoding='utf8', header=0, sep=';')
# erstelle die x_train Trainingsdatenrohlinge aus den jeweiligen Spaltennamen
x_train = data[['x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']]
x_train = x_train.astype('int64').to_numpy()
# erstelle y_train Trainingsdatenrohlinge aus den jeweiligen Spaltennamen
y_train = data[
['x1_rotated', 'y1_rotated', 'x2_rotated', 'y2_rotated', 'x3_rotated', 'y3_rotated', 'x4_rotated',
'y4_rotated']]
y_train = y_train.astype('int64').to_numpy()
# erstelle Trainings und Testdaten
train_features, test_features, train_target, test_target = train_test_split(x_train, y_train, test_size=0.1,
random_state=0)
# erstellen des neuronalen Netzwerks
network = models.Sequential()
# füge die Daten dem Netz hinzu mit der Aktivierungsfunktion ReLu
network.add(layers.Dense(units=50, activation='relu', input_shape=(train_features.shape[1],)))
# füge eine Ebene ohne Aktivierungsfunktion hinzu
network.add(layers.Dense(units=8))
# Berechne das Netzwerk
network.compile(loss='mse', optimizer='RMSprop', metrics=['mse'])
# Trainiere das Netzwerk
history = network.fit(train_features, train_target, epochs=5, verbose=1, batch_size=100,
validation_data=(test_features, test_target))
# Prediction
print(
'Correct rotation of the square with the points (x&y): 1&9, 3&9, 3&11, 1&11: [[ -9 1 -9 3 -11 3 -11 1]]')
print('Prediction for the square with the corner points: 1&9, 3&9, 3&11, 1&11: ',
network.predict(np.array([[1, 9, 3, 9, 3, 11, 1, 11]]), verbose=0))
# erhalten des Ergebnisses der Vorhersage des Netzwerks
result = network.predict(np.array([[1, 9, 3, 9, 3, 12, 1, 12]]), verbose=0)
# erstelle 2 Listen
x1, y1 = [], []
# für jeden Wert von 0 bis zur länge der ersten Liste des Ergebnisses
for i in range(len(result[0])):
# Wenn der Rest von i / 2 = 0 ist
if i % 2 == 0:
# füge x1 den i-ten Wert von der ersten Liste des Ergebnisses hinzu
x1.append(result[0][i])
# Wenn der Rest von i / 2 nicht gleich 0 ist
else:
# füge y1 den i-ten Wert von der ersten Liste des Ergebnisses hinzu
y1.append(result[0][i])
# definiere x und y
x = [1, 3, 3, 1]
y = [9, 9, 12, 12]
# erstelle Plots
fig, ax = plt.subplots()
# Fülle die Fläche zwischen den x und y Werten
ax.fill(x, y)
# Fülle die Fläche zwischen den x1 und y1 Werten
ax.fill(x1, y1)
# Zeige das Plot
plt.show()
if __name__ == "__main__":
data = RectangleX()
# data.generate_rectangle_test_data()
# data.rectangles_x()
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment