def test_split():
try:
X = np.ones((5, 2))
Y = np.ones(6)
X_1, X_2, Y_1, Y_2 = splitter.split(
X, Y, percentage=0.5, random_state=1)
except:
X = np.ones((6, 2))
Y = np.ones(6)
X_1, X_2, Y_1, Y_2 = splitter.split(
X, Y, percentage=0.5, random_state=1)
assert X_1.shape == (3, 2)
assert X_2.shape == (3, 2)
assert Y_1.shape == (3,)
assert Y_2.shape == (3,)
def test_opf_pre_compute_distances():
txt = loader.load_txt('data/boat.txt')
X, Y = parser.parse_loader(txt)
X_train, _, _, _ = splitter.split(X, Y, 0.5, 1)
general.pre_compute_distance(X_train, 'boat_split_distances.txt', 'log_squared_euclidean')
def test_supervised_opf_prune():
opf = supervised.SupervisedOPF()
X_train, X_val, Y_train, Y_val = splitter.split(X,
Y,
percentage=0.1,
random_state=1)
opf.prune(X_train, Y_train, X_val, Y_val, n_iterations=5)
assert opf.subgraph.n_nodes == 10
def test_supervised_opf_learn():
opf = supervised.SupervisedOPF()
X_train, X_val, Y_train, Y_val = splitter.split(X,
Y,
percentage=0.1,
random_state=1)
opf.learn(X_train, Y_train, X_val, Y_val, n_iterations=5)
assert isinstance(opf, supervised.SupervisedOPF)
def use_split(X, Y, test_size=0.1, random_state=0):
"""Splits the data into training and testing sets.
Args:
X (np.array): Input samples array.
Y (np.array): Input labels array.
test_size (float): Size of the testing set.
random_state (int): Random integer to provide a random state to splitter.
"""
# Splitting data into training and testing sets
X_train, X_test, Y_train, Y_test = s.split(X,
Y,
percentage=1 - test_size,
random_state=random_state)
return X_train, X_test, Y_train, Y_test
from opytimizer.core import Function
from opytimizer.optimizers.boolean import BPSO
from opytimizer.spaces import BooleanSpace
# Loads digits dataset
digits = load_digits()
# Gathers samples and targets
X = digits.data
Y = digits.target
# Adding 1 to labels, i.e., OPF should have labels from 1+
Y += 1
# Splits data into training and testing sets
X_train, X_val, Y_train, Y_val = s.split(X, Y, percentage=0.5, random_state=1)
def supervised_opf_feature_selection(opytimizer):
# Gathers features
features = opytimizer[:, 0].astype(bool)
# Remaking training and validation subgraphs with selected features
X_train_selected = X_train[:, features]
X_val_selected = X_val[:, features]
# Creates a SupervisedOPF instance
opf = SupervisedOPF(distance='log_squared_euclidean',
pre_computed_distance=None)
# Fits training data into the classifier
from opytimizer.optimizers.swarm import PSO
from opytimizer.spaces import SearchSpace
# Loads digits dataset
digits = load_digits()
# Gathers samples and targets
X = digits.data
Y = digits.target
# Adding 1 to labels, i.e., OPF should have labels from 1+
Y += 1
# Splits data into training and testing sets
X_train, X_test, Y_train, Y_test = s.split(X,
Y,
percentage=0.5,
random_state=1)
def unsupervised_opf_clustering(opytimizer):
# Gathers parameters from Opytimizer
# Pay extremely attention to their order when declaring due to their bounds
max_k = int(opytimizer[0][0])
# Creates an UnsupervisedOPF instance
opf = UnsupervisedOPF(max_k=max_k,
distance='log_squared_euclidean',
pre_computed_distance=None)
# Fits training data into the classifier
opf.fit(X_train, Y_train)
import opfython.math.general as g
import opfython.stream.loader as l
import opfython.stream.parser as p
import opfython.stream.splitter as s
from opfython.models.semi_supervised import SemiSupervisedOPF
# Loading a .txt file to a numpy array
txt = l.load_txt('data/boat.txt')
# Parsing a pre-loaded numpy array
X, Y = p.parse_loader(txt)
# Splitting data into training and testing sets
X_train, X_test, Y_train, Y_test = s.split(X,
Y,
percentage=0.8,
random_state=1)
#Splitting data into training and validation sets
X_train, X_unlabeled, Y_train, Y_unlabeled = s.split(X_train,
Y_train,
percentage=0.25,
random_state=1)
# Creates a SemiSupervisedOPF instance
opf = SemiSupervisedOPF(distance='log_squared_euclidean',
pre_computed_distance=None)
# Fits training data along with unlabeled data into the semi-supervised classifier
opf.fit(X_train, Y_train, X_unlabeled)
import opfython.math.general as g
import opfython.stream.loader as l
import opfython.stream.parser as p
import opfython.stream.splitter as s
from opfython.models import KNNSupervisedOPF
# Loading a .txt file to a numpy array
txt = l.load_txt('data/boat.txt')
# Parsing a pre-loaded numpy array
X, Y = p.parse_loader(txt)
# Splitting data into training and testing sets
X_train, X_test, Y_train, Y_test = s.split(
X, Y, percentage=0.8, random_state=1)
# Splitting data into training and validation sets
X_train, X_val, Y_train, Y_val = s.split(
X_train, Y_train, percentage=0.25, random_state=1)
# Creates an KNNSupervisedOPF instance
opf = KNNSupervisedOPF(max_k=10, distance='log_squared_euclidean', pre_computed_distance=None)
# Fits training data into the classifier
opf.fit(X_train, Y_train, X_val, Y_val)
# Predicts new data
preds = opf.predict(X_test)
# Calculating accuracy
acc = g.opf_accuracy(Y_test, preds)
