def fashion_mnist_example():
dtype_1 = np.complex64
fashion_mnist = tf.keras.datasets.fashion_mnist
(train_images, train_labels), (test_images,
test_labels) = fashion_mnist.load_data()
train_images = train_images.astype(dtype_1)
test_images = test_images.astype(dtype_1)
train_labels = train_labels.astype(dtype_1)
test_labels = test_labels.astype(dtype_1)
model = tf.keras.Sequential([
ComplexInput(input_shape=(28, 28)),
ComplexFlatten(),
ComplexDense(128,
activation='cart_relu',
kernel_initializer=ComplexGlorotUniform(seed=0)),
ComplexDense(10,
activation='convert_to_real_with_abs',
kernel_initializer=ComplexGlorotUniform(seed=0))
])
model.summary()
model.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=2)
def shape_tst(input_size, output_size, shape_raw, classifier=True, capacity_equivalent=True,
equiv_technique='alternate', expected_result=None):
shape = [
layers.ComplexInput(input_shape=input_size, dtype=np.complex64)
]
if len(shape_raw) == 0:
shape.append(
ComplexDense(units=output_size, activation='softmax_real', dtype=np.complex64)
)
else: # len(shape_raw) > 0:
for s in shape_raw:
shape.append(ComplexDense(units=s, activation='cart_relu')) # Add dropout!
shape.append(ComplexDense(units=output_size, activation='softmax_real'))
complex_network = Sequential(shape, name="complex_network")
complex_network.compile(optimizer='sgd', loss=categorical_crossentropy, metrics=['accuracy'])
result = _get_real_equivalent_multiplier(complex_network.layers, classifier=classifier,
capacity_equivalent=capacity_equivalent,
equiv_technique=equiv_technique)
# rvnn = complex_network.get_real_equivalent(classifier, capacity_equivalent)
# complex_network.training_param_summary()
# rvnn.training_param_summary()
if expected_result is not None:
assert np.all(expected_result == result), f"Expecting result {expected_result} but got {result}."
else:
print(result)
def serial_layers():
model = Sequential()
model.add(ComplexDense(32, activation='relu', input_shape=(32, 32, 3)))
model.add(ComplexDense(32))
print(model.output_shape)
img_r = np.array([[
[0, 1, 2],
[0, 2, 2],
[0, 5, 7]
], [
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
]]).astype(np.float32)
img_i = np.array([[
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
], [
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
]]).astype(np.float32)
img = img_r + 1j * img_i
model = Sequential()
# model.add(ComplexInput(img.shape[1:]))
model.add(ComplexFlatten(input_shape=img.shape[1:]))
model.add(ComplexDense(units=10))
res = model(img)
def dense_example():
img_r = np.array([[
[0, 1, 2],
[0, 2, 2],
[0, 5, 7]
], [
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
]]).astype(np.float32)
img_i = np.array([[
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
], [
[0, 4, 5],
[3, 7, 9],
[4, 5, 3]
]]).astype(np.float32)
img = img_r + 1j * img_i
c_flat = ComplexFlatten()
c_dense = ComplexDense(units=10)
res = c_dense(c_flat(img.astype(np.complex64)))
assert res.shape == [2, 10]
assert res.dtype == tf.complex64
model = tf.keras.models.Sequential()
model.add(ComplexInput(input_shape=(3, 3)))
model.add(ComplexFlatten())
model.add(ComplexDense(32, activation='cart_relu'))
model.add(ComplexDense(32))
assert model.output_shape == (None, 32)
res = model(img.astype(np.complex64))
def ace():
y_pred = np.random.rand(3, 43, 12, 10)
y_true = np.random.rand(3, 43, 12, 10)
tf_result = CategoricalCrossentropy()(y_pred=y_pred, y_true=y_true)
own_result = ComplexAverageCrossEntropy()(y_pred=tf.complex(y_pred, y_pred), y_true=y_true)
assert tf_result == own_result, f"ComplexCrossentropy {own_result} != CategoricalCrossentropy {tf_result}"
m = 10000
n = 128
param_list = [
[0.3, 1, 1],
[-0.3, 1, 1]
]
dataset = dp.CorrelatedGaussianCoeffCorrel(m, n, param_list, debug=False)
model = tf.keras.models.Sequential([
complex_input(shape=(n)),
ComplexDense(units=50, activation="cart_relu"),
ComplexDense(2, activation="cart_softmax")
])
model.compile(loss=ComplexAverageCrossEntropy(), metrics=["accuracy"], optimizer="sgd")
model.fit(dataset.x, dataset.y, epochs=6)
def mnist_example():
(ds_train, ds_test), ds_info = tfds.load(
'mnist',
split=['train', 'test'],
shuffle_files=True,
as_supervised=True,
with_info=True,
)
ds_train = ds_train.map(normalize_img,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds_train = ds_train.cache()
ds_train = ds_train.shuffle(ds_info.splits['train'].num_examples)
ds_train = ds_train.batch(128)
ds_train = ds_train.prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test.map(normalize_img,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds_test = ds_test.batch(128)
ds_test = ds_test.cache()
ds_test = ds_test.prefetch(tf.data.experimental.AUTOTUNE)
model = tf.keras.models.Sequential([
ComplexFlatten(input_shape=(28, 28, 1)),
ComplexDense(128, activation='relu', dtype=tf.float32),
ComplexDense(10, dtype=tf.float32)
])
model.compile(
optimizer=tf.keras.optimizers.Adam(0.001),
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],
)
model.fit(
ds_train,
epochs=2,
validation_data=ds_test,
)
def mlp_run_real_comparison_montecarlo(dataset: cvnn.dataset.Dataset, open_dataset: Optional[t_path] = None,
iterations: int = 1000,
epochs: int = 150, batch_size: int = 100, display_freq: int = 1,
optimizer='sgd', # TODO: Typing
shape_raw=None, activation: t_activation = 'cart_relu',
debug: bool = False, polar: bool = False, do_all: bool = True,
dropout: float = 0.5, validation_split: float = 0.2,
validation_data: Optional[Union[Tuple, data.Dataset]] = None, # TODO: Add typing of tuple
capacity_equivalent: bool = True, equiv_technique: str = 'ratio',
do_conf_mat: bool = True, checkpoints: bool = False,
shuffle: bool = False) -> str:
"""
This function is used to compare CVNN vs RVNN performance over any dataset.
1. Automatically creates two Multi-Layer Perceptrons (MLP), one complex and one real.
2. Runs simulation and compares them.
3. Saves several files into ./log/montecarlo/date/of/run/
3.1. run_summary.txt: Summary of the run models and data
3.2. run_data.csv: Full information of performance of iteration of each model at each epoch
3.3. complex_network_statistical_result.csv: Statistical results of all iterations of CVNN per epoch
3.4. real_network_statistical_result.csv: Statistical results of all iterations of RVNN per epoch
3.5. (Optional) `plot/` folder with the corresponding plots generated by MonteCarloAnalyzer.do_all()
:param dataset: cvnn.dataset.Dataset with the dataset to be used on the training
:param open_dataset: (None)
If dataset is saved inside a folder and must be opened, path of the Dataset to be opened. Else None (default)
:param iterations: Number of iterations to be done for each model
:param epochs: Number of epochs for each iteration
:param batch_size: Batch size at each iteration
:param display_freq: Frequency in terms of epochs of when to do a checkpoint.
:param optimizer: Optimizer to be used. Keras optimizers are not allowed.
Can be either cvnn.optimizers.Optimizer or a string listed in opt_dispatcher.
:param shape_raw: List of sizes of each hidden layer.
For example [64] will generate a CVNN with one hidden layer of size 64.
Default None will default to example.
:param activation: Activation function to be used at each hidden layer
:param debug:
:param polar: Boolean weather the RVNN should receive real and imaginary part (False) or amplitude and phase (True)
:param do_all: If true (default) it creates a `plot/` folder with the plots generated by MonteCarloAnalyzer.do_all()
:param dropout: (float) Dropout to be used at each hidden layer. If None it will not use any dropout.
:param validation_split: Float between 0 and 1.
Percentage of the input data to be used as test set (the rest will be use as train set)
Default: 0.0 (No validation set).
This input is ignored if validation_data is given.
:param validation_data: Data on which to evaluate the loss and any model metrics at the end of each epoch.
The model will not be trained on this data. This parameter takes precedence over validation_split.
It can be:
- tuple (x_val, y_val) of Numpy arrays or tensors. Preferred data type (less overhead).
- A tf.data dataset.
:param capacity_equivalent: An equivalent model can be equivalent in terms of layer neurons or
trainable parameters (capacity equivalent according to: https://arxiv.org/abs/1811.12351)
- True, it creates a capacity-equivalent model in terms of trainable parameters
- False, it will double all layer size (except the last one if classifier=True)
:param equiv_technique: Used to define the strategy of the capacity equivalent model.
This parameter is ignored if capacity_equivalent=False
- 'ratio': neurons_real_valued_layer[i] = r * neurons_complex_valued_layer[i], 'r' constant for all 'i'
- 'alternate': Method described in https://arxiv.org/abs/1811.12351 where one alternates between
multiplying by 2 or 1. Special case on the middle is treated as a compromise between the two.
:param do_conf_mat: Generate a confusion matrix based on results.
:return: (string) Full path to the run_data.csv generated file.
It can be used by cvnn.data_analysis.SeveralMonteCarloComparison to compare several runs.
"""
if shape_raw is None:
shape_raw = [64]
if open_dataset:
dataset = dp.OpenDataset(open_dataset) # Warning, open_dataset overwrites dataset
# Create complex network
input_size = dataset.x.shape[1] # Size of input
output_size = dataset.y.shape[1] # Size of output
shape = [
layers.ComplexInput(input_shape=input_size)
]
if len(shape_raw) == 0:
logger.warning("No hidden layers are used. activation and dropout will be ignored")
shape.append(
ComplexDense(units=output_size, activation='softmax_real', input_dtype=np.complex64)
)
else: # len(shape_raw) > 0:
for s in shape_raw:
shape.append(ComplexDense(units=s, activation=activation)) # Add dropout!
if dropout is not None:
shape.append(ComplexDropout(rate=dropout))
shape.append(ComplexDense(units=output_size, activation='softmax_real'))
complex_network = tf.keras.Sequential(shape, name="complex_network")
complex_network.compile(optimizer=optimizer, loss=tf.keras.losses.CategoricalCrossentropy(), metrics=['accuracy'])
# Monte Carlo
monte_carlo = RealVsComplex(complex_network,
capacity_equivalent=capacity_equivalent, equiv_technique=equiv_technique)
sleep(1) # I have error if not because not enough time passed since creation of models to be in diff folders
monte_carlo.run(dataset.x, dataset.y, iterations=iterations,
epochs=epochs, batch_size=batch_size, display_freq=display_freq,
shuffle=shuffle, debug=debug, data_summary=dataset.summary(), polar=polar,
validation_split=validation_split, validation_data=validation_data, do_conf_mat=do_conf_mat,
checkpoints=checkpoints)
if do_all:
monte_carlo.monte_carlo_analyzer.do_all()
# Save data to remember later what I did.
max_epoch = monte_carlo.pandas_full_data['epoch'].max()
epoch_filter = monte_carlo.pandas_full_data['epoch'] == max_epoch
complex_filter = monte_carlo.pandas_full_data['network'] == "complex_network"
real_filter = monte_carlo.pandas_full_data['network'] == "real_network"
complex_last_epochs = monte_carlo.pandas_full_data[epoch_filter & complex_filter]
real_last_epochs = monte_carlo.pandas_full_data[epoch_filter & real_filter]
complex_median = complex_last_epochs['accuracy'].median()
real_median = real_last_epochs['accuracy'].median()
complex_median_train = complex_last_epochs['val_accuracy'].median()
real_median_train = real_last_epochs['val_accuracy'].median()
_save_rvnn_vs_cvnn_montecarlo_log(
iterations=iterations,
path=str(monte_carlo.monte_carlo_analyzer.path),
dataset_name=dataset.dataset_name,
optimizer=str(complex_network.optimizer.__class__),
loss=str(complex_network.loss.__class__),
hl=str(len(shape_raw)), shape=str(shape_raw),
dropout=str(dropout), num_classes=str(dataset.y.shape[1]),
polar_mode='Yes' if polar else 'No',
activation=activation,
dataset_size=str(dataset.x.shape[0]), feature_size=str(dataset.x.shape[1]),
epochs=epochs, batch_size=batch_size,
winner='CVNN' if complex_median > real_median else 'RVNN',
complex_median=complex_median, real_median=real_median,
complex_median_train=complex_median_train, real_median_train=real_median_train,
complex_err=median_error(complex_last_epochs['accuracy'].quantile(.75),
complex_last_epochs['accuracy'].quantile(.25), iterations),
real_err=median_error(real_last_epochs['val_accuracy'].quantile(.75),
real_last_epochs['val_accuracy'].quantile(.25), iterations),
filename='./log/mlp_montecarlo_summary.xlsx'
)
return str(monte_carlo.monte_carlo_analyzer.path / "run_data.csv")
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras import layers
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import datasets
from cvnn.layers import ComplexDense, ComplexFlatten
from pdb import set_trace
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()
train_images, test_images = tf.cast(train_images, tf.complex64) / 255.0, tf.cast(test_images, tf.complex64) / 255.0
model = Sequential([
ComplexFlatten(input_shape=(28, 28, 1)),
ComplexDense(128, activation='relu', input_shape=(28, 28, 1)),
ComplexDense(10, activation='softmax')
])
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=Adam(0.001),
metrics=['accuracy'],
)
print(model.predict(train_images[:10]).dtype)
# model.fit(
# train_images, train_labels,
# epochs=6,
# validation_data=(test_images, test_labels),
# )