def create(self,
data,
row_labels=None,
col_labels=None,
foldin=False,
truncate=False):
#is_row is what I'm originally folding in
self._values = map(itemgetter(0), data)
self._rows = map(itemgetter(1), data)
self._cols = map(itemgetter(2), data)
if foldin: #new to make sure not folding in user and item at same time
#idea: create matrix normally but keep track of the columns (items) or rows to be folded in before doing update
if col_labels: #if col_labels defined then I'm folding in a row
self._additional_elements = [
x for x in self._cols if x not in col_labels
]
else: #else I am folding in a column
self._additional_elements = [
x for x in self._rows if x not in row_labels
]
if truncate:
for item in self._additional_elements:
if col_labels:
index_remove = self._cols.index(item)
else:
index_remove = self._rows.index(item)
del self._values[index_remove]
del self._rows[index_remove]
del self._cols[index_remove]
self._matrix = divisiSparseMatrix.from_named_lists(
self._values, self._rows, self._cols, row_labels, col_labels)
def update(
self,
matrix,
is_batch=False
): #isbatch is for creating the final sparse matrix ,since you will want to collect all then construct final matrix at end
#To update the stored data matrix with the new values and create a new divisi spare matrix with it to retain the zeroes
self._values.extend(matrix._values)
self._rows.extend(matrix._rows)
self._cols.extend(matrix._cols)
if not is_batch:
self._matrix = divisiSparseMatrix.from_named_lists(
self._values, self._rows, self._cols)
def blend(mats, factors=None, symmetric=False, post_weights=None):
"""
Combine multiple labeled matrices into one, with weighted data from
all the matrices.
mats: a list of matrices to blend.
factors: List of scaling factor for each matrix.
If None, the reciprocal of the first singular value is used.
post_weights: List of weights to apply to each scaled matrix.
You can use this to, for example, say that one matrix is twice as
important as another. If None, no post-weighting is performed.
symmetric: Use square_from_named_lists.
"""
assert len(mats) > 0
if len(mats) == 1:
if factors is None: return mats[0]
else: return mats[0] * factors[0]
b_values = []
b_row_labels = []
b_col_labels = []
if factors is None:
factors = [blend_factor(mat) for mat in mats]
if post_weights is not None:
factors = [
factor * post_weight
for factor, post_weight in zip(factors, post_weights)
]
for mat, factor in zip(mats, factors):
# FIXME: using bare find(), multiplying in numpy form, and
# translating the labels manually would be a bit faster
values, row_labels, col_labels = mat.named_lists()
b_values.extend([v * factor for v in values])
b_row_labels.extend(row_labels)
b_col_labels.extend(col_labels)
if symmetric:
return SparseMatrix.square_from_named_lists(b_values, b_row_labels,
b_col_labels)
else:
return SparseMatrix.from_named_lists(b_values, b_row_labels,
b_col_labels)
def blend(mats, factors=None, symmetric=False, post_weights=None):
"""
Combine multiple labeled matrices into one, with weighted data from
all the matrices.
mats: a list of matrices to blend.
factors: List of scaling factor for each matrix.
If None, the reciprocal of the first singular value is used.
post_weights: List of weights to apply to each scaled matrix.
You can use this to, for example, say that one matrix is twice as
important as another. If None, no post-weighting is performed.
symmetric: Use square_from_named_lists.
"""
assert len(mats) > 0
if len(mats) == 1:
if factors is None: return mats[0]
else: return mats[0] * factors[0]
b_values = []
b_row_labels = []
b_col_labels = []
if factors is None:
factors = [blend_factor(mat) for mat in mats]
if post_weights is not None:
factors = [factor*post_weight for factor, post_weight in zip(factors, post_weights)]
for mat, factor in zip(mats, factors):
# FIXME: using bare find(), multiplying in numpy form, and
# translating the labels manually would be a bit faster
values, row_labels, col_labels = mat.named_lists()
b_values.extend([v*factor for v in values])
b_row_labels.extend(row_labels)
b_col_labels.extend(col_labels)
if symmetric:
return SparseMatrix.square_from_named_lists(b_values, b_row_labels, b_col_labels)
else:
return SparseMatrix.from_named_lists(b_values, b_row_labels, b_col_labels)
def index_sparseMatrix(
self
): #create the divisi2 sparse matrix from already existing values
self._matrix = divisiSparseMatrix.from_named_lists(
self._values, self._rows, self._cols)
def create(self, data):
values = map(itemgetter(0), data)
rows = map(itemgetter(1), data)
cols = map(itemgetter(2), data)
self._matrix = divisiSparseMatrix.from_named_lists(values, rows, cols)
def create(self, data):
values = map(itemgetter(0), data)
rows = map(itemgetter(1), data)
cols = map(itemgetter(2), data)
self._matrix = divisiSparseMatrix.from_named_lists(values, rows, cols)
