def send_output(self):
if self.data is not None:
relation_ = None
if isinstance(self.data, Relation):
relation_ = Relation(self.data.relation)
if self.row_type:
relation_.relation.row_type = fusion.ObjectType(
self.row_type)
if self.col_type:
relation_.relation.col_type = fusion.ObjectType(
self.col_type)
else:
relation_ = Relation.create(
self.data.X, fusion.ObjectType(self.row_type or "Unknown"),
fusion.ObjectType(self.col_type or "Unknown"))
oos_mask = hide_data(relation_, self.percent / 100,
SampleBy.all[self.method])
def _mask_relation(relation, mask):
if np.ma.is_masked(relation.data):
mask = np.logical_or(mask, relation.data.mask)
data = copy.copy(relation)
data.data = np.ma.array(data.data, mask=mask)
return data
oos_mask = _mask_relation(relation_.relation, oos_mask)
self.send(Output.IN_SAMPLE_DATA, Relation(oos_mask))
self.send(Output.OUT_OF_SAMPLE_DATA, Relation(oos_mask))
def send_output(self):
if self.movies is not None:
movie_actor_mat, actors = movielens.movie_concept_matrix(self.movies, concept="actor",
actors=self.percent)
actor_actor_mat = movielens.actor_matrix(movie_actor_mat)
movies_actors = fusion.Relation(movie_actor_mat.T, name='play in',
row_type=movielens.ObjectType.Actors, row_names=actors,
col_type=movielens.ObjectType.Movies, col_names=self.movies)
self.Outputs.movie_actors.send(Relation(movies_actors))
actors_actors = fusion.Relation(actor_actor_mat, name='costar with',
row_type=movielens.ObjectType.Actors, row_names=actors,
col_type=movielens.ObjectType.Actors, col_names=actors)
self.Outputs.actors_actors.send(Relation(actors_actors))
def send_output(self):
if self.data is not None:
relation_ = None
if isinstance(self.data, Relation):
relation_ = Relation(self.data.relation)
if self.row_type:
relation_.relation.row_type = fusion.ObjectType(self.row_type)
if self.col_type:
relation_.relation.col_type = fusion.ObjectType(self.col_type)
else:
relation_ = Relation.create(self.data.X,
fusion.ObjectType(self.row_type or "Unknown"),
fusion.ObjectType(self.col_type or "Unknown"))
oos_mask = hide_data(relation_,
self.percent / 100,
SampleBy.all[self.method])
def _mask_relation(relation, mask):
if np.ma.is_masked(relation.data):
mask = np.logical_or(mask, relation.data.mask)
data = copy.copy(relation)
data.data = np.ma.array(data.data, mask=mask)
return data
oos_mask = _mask_relation(relation_.relation, oos_mask)
self.Outputs.in_sample_data.send(Relation(oos_mask))
self.Outputs.out_of_sample_data.send(Relation(oos_mask))
def commit(self):
if self.data:
domain = self.data.domain
metadata_cols = list(domain.class_vars) + list(domain.metas)
metadata = [{
var: var.to_val(value)
for var, value in zip(metadata_cols, values.list)
} for values in self.data[:, metadata_cols]]
if self.transpose:
relation = fusion.Relation(
self.data.X.T,
name=self.relation_name,
row_type=fusion.ObjectType(self.col_type or 'Unknown'),
row_names=self.col_names,
col_type=fusion.ObjectType(self.row_type or 'Unknown'),
col_names=self.row_names,
col_metadata=metadata)
else:
relation = fusion.Relation(
self.data.X,
name=self.relation_name,
row_type=fusion.ObjectType(self.row_type or 'Unknown'),
row_names=self.row_names,
row_metadata=metadata,
col_type=fusion.ObjectType(self.col_type or 'Unknown'),
col_names=self.col_names,
)
self.Outputs.relation.send(Relation(relation))
def send_output(self):
if self.relation is not None:
oos_mask = hide_data(self.relation, self.percent / 100,
SampleBy.all[self.method])
def _mask_relation(relation, mask):
if np.ma.is_masked(relation.data):
mask = np.logical_or(mask, relation.data.mask)
data = copy.copy(relation)
data.data = np.ma.array(data.data, mask=mask)
return data
oos_mask = _mask_relation(self.relation.relation, oos_mask)
self.send(Output.IN_SAMPLE_DATA, Relation(oos_mask))
self.send(Output.OUT_OF_SAMPLE_DATA, Relation(oos_mask))
def send_output(self):
if self.data is not None:
relation = fusion.Relation(self.matrix,
name=self.relation_name,
row_type=self.row_type,
row_names=self.row_names,
col_type=fusion.ObjectType("Genres"),
col_names=self.genres)
self.send("Genres", Relation(relation))
def selectionChanged(self, selected, deselected):
super().selectionChanged(selected, deselected)
if not selected:
relation = None
else:
assert len(selected) == 1
data = self._parent.tablemodel[selected[0].top()][0]
relation = Relation(data)
self._parent.Outputs.relation.send(relation)
def main():
from sklearn.datasets import make_blobs
import numpy as np
from AnyQt.QtWidgets import QApplication
from orangecontrib.datafusion.models import FittedFusionGraph
from orangecontrib.datafusion.widgets.owmeanfuser import MeanFuser
X, y = make_blobs(100,
3,
centers=2,
center_box=(-100, 100),
cluster_std=10)
X = X.astype(int)
X += abs(X.min())
nrows, ncols, _ = X.max(0)
R1 = np.zeros((nrows + 1, ncols + 1))
R1[X[:, 0], X[:, 1]] = X[:, 2]
R1 = np.ma.array((R1 - R1.min()) / (R1.max() - R1.min()))
_, ncols, nrows = X.max(0)
R2 = np.zeros((nrows + 1, ncols + 1))
R2[X[:, 2], X[:, 1]] = X[:, 0]
R2 = np.ma.array((R2 - R2.min()) / (R2.max() - R2.min()))
t1 = fusion.ObjectType('Users', 10)
t2 = fusion.ObjectType('Movies', 30)
t3 = fusion.ObjectType('Actors', 40)
relations = [
fusion.Relation(R1, t1, t2, name='like'),
fusion.Relation(R2, t3, t2, name='feature in'),
]
G = fusion.FusionGraph()
for relation in relations:
relation.data.mask = np.random.rand(*relation.data.shape) > .8
G.add_relation(relation)
fuserF = fusion.Dfmf()
fuserF.fuse(G)
from copy import deepcopy
G = deepcopy(G)
fuserC = fusion.Dfmc()
fuserC.name = 'My dfmc<3'
fuserC.fuse(G)
app = QApplication([])
w = OWCompletionScoring()
w.on_fuser_change(FittedFusionGraph(fuserF), fuserF.__class__.__name__)
w.on_fuser_change(FittedFusionGraph(fuserC), fuserC.__class__.__name__)
w.on_fuser_change(MeanFuser(0), 'meanfuser0')
w.on_fuser_change(MeanFuser(1), 'meanfuser1')
w.on_fuser_change(MeanFuser(2), 'meanfuser2')
for i, relation in enumerate(relations, 1):
w.on_relation_change(Relation(relation), i)
w.show()
app.exec()
def commit(self, item=None):
self.fuser = MeanFuser(self.mean_by)
self.Outputs.fuser.send(self.fuser)
rows = [i.row() for i in self.table.selectionModel().selectedRows()]
if self.model.rowCount() and rows:
relation = self.model[rows[0]][0]
data = Relation.create(self.fuser.complete(relation),
relation.row_type, relation.col_type,
self.graph)
else:
data = None
self.Outputs.relation.send(data)
def commit(self, item=None):
self.fuser = MeanFuser(self.mean_by)
self.send(Output.FUSER, self.fuser)
rows = [i.row() for i in self.table.selectionModel().selectedRows()]
if self.model.rowCount() and rows:
relation = self.model[rows[0]][0]
data = Relation.create(self.fuser.complete(relation),
relation.row_type,
relation.col_type,
self.graph)
else:
data = None
self.send(Output.RELATION, data)
def commit(self, item=None):
self.fuser = MeanFuser(self.mean_by)
self.send(Output.FUSER, self.fuser)
selection = self.table.selectedRanges()
if self.table.rowCount() and selection:
relation = self.table.rowData(selection[0].topRow())
data = Relation.create(self.fuser.complete(relation),
relation.row_type,
relation.col_type,
self.graph)
else:
data = None
self.send(Output.RELATION, data)
def send_output(self):
if self.method == 0:
matrix, movies, users = movielens.movie_user_matrix(
percentage=self.percent)
else:
try:
matrix, movies, users = movielens.movie_user_matrix(
start_year=self.start, end_year=self.end)
except ValueError:
self.error(0, "Invalid starting years")
self.Outputs.relation.send(None)
relation = fusion.Relation(matrix.T,
name='rate',
row_type=movielens.ObjectType.Users,
row_names=users,
col_type=movielens.ObjectType.Movies,
col_names=movies)
self.Outputs.relation.send(Relation(relation))
def send_output(self):
if self.method == 0:
matrix, movies, users = movielens.movie_user_matrix(
percentage=self.percent)
else:
try:
matrix, movies, users = movielens.movie_user_matrix(
start_year=self.start, end_year=self.end)
except ValueError:
self.error(0, "Invalid starting years")
self.send("Ratings", None)
def scale(X):
return (X - np.nanmin(X)) / (np.nanmax(X) - np.nanmin(X))
relation = fusion.Relation(matrix.T,
name='rate',
row_type=movielens.ObjectType.Users,
row_names=users,
col_type=movielens.ObjectType.Movies,
col_names=movies,
preprocessor=scale)
self.send("Ratings", Relation(relation))
def commit(self, item):
data = Relation.create(*item, graph=self.fuser) if item else None
self.send(Output.RELATION, data)
def commit(self, item):
data = Relation.create(*item.tableWidget().rowData(item.row()), graph=self.fuser) if item else None
self.send(Output.RELATION, data)
def commit(self, item):
data = item.data(QtCore.Qt.UserRole)
self.send(Output.RELATION, Relation.create(*data, graph=self.fuser))
def commit(self, item):
data = Relation.create(*item, graph=self.fuser) if item else None
self.Outputs.relation.send(data)
def send_relation(item):
data = item.data(QtCore.Qt.UserRole)
self.send(Output.RELATION, Relation(data))
