def plot(
self,
kind: str = "arrow",
x_axis: Union[int, str, Embedding] = None,
y_axis: Union[int, str, Embedding] = None,
x_label: Optional[str] = None,
y_label: Optional[str] = None,
title: Optional[str] = None,
color: str = None,
show_ops: bool = False,
annot: bool = True,
axis_option: Optional[str] = None,
):
"""
Makes (perhaps inferior) matplotlib plot. Consider using `plot_interactive` instead.
Arguments:
kind: what kind of plot to make, can be `scatter`, `arrow` or `text`
x_axis: the x-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
y_axis: the y-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
x_label: an optional label used for x-axis; if not given, it is set based on value of `x_axis`.
y_label: an optional label used for y-axis; if not given, it is set based on value of `y_axis`.
title: an optional title for the plot.
color: the color of the dots
show_ops: setting to also show the applied operations, only works for `text`
annot: should the points be annotated
axis_option: a string which is passed as `option` argument to `matplotlib.pyplot.axis` in order to control
axis properties (e.g. using `'equal'` make circles shown circular in the plot). This might be useful
for preserving geometric relationships (e.g. orthogonality) in the generated plot. See `matplotlib.pyplot.axis`
[documentation](https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.axis.html#matplotlib-pyplot-axis)
for possible values and their description.
"""
if isinstance(x_axis, str):
x_axis = self[x_axis]
if isinstance(y_axis, str):
y_axis = self[y_axis]
embeddings = []
for emb in self.embeddings.values():
x_val, x_lab = emb._get_plot_axis_value_and_label(x_axis, dir="x")
y_val, y_lab = emb._get_plot_axis_value_and_label(y_axis, dir="y")
emb_plot = Embedding(name=emb.name,
vector=[x_val, y_val],
orig=emb.orig)
embeddings.append(emb_plot)
x_label = x_lab if x_label is None else x_label
y_label = y_lab if y_label is None else y_label
handle_2d_plot(
embeddings,
kind=kind,
color=color,
xlabel=x_label,
ylabel=y_label,
title=title,
show_operations=show_ops,
annot=annot,
axis_option=axis_option,
)
return self
def plot(self,
kind="scatter",
x_axis=None,
y_axis=None,
color=None,
show_operations=False):
"""
Handles the logic to perform a 2d plot in matplotlib.
**Input**
- kind: what kind of plot to make, can be `scatter`, `arrow` or `text`
- color: the color to apply, only works for `scatter` and `arrow`
- xlabel: manually override the xlabel
- ylabel: manually override the ylabel
- show_operations: setting to also show the applied operations, only works for `text`
"""
if len(self.vector) == 2:
handle_2d_plot(self,
kind=kind,
color=color,
show_operations=show_operations)
else:
x_val = self > x_axis
y_val = self > y_axis
intermediate = Embedding(name=self.name,
vector=[x_val, y_val],
orig=self.orig)
handle_2d_plot(intermediate,
kind=kind,
color=color,
xlabel=x_axis.name,
ylabel=y_axis.name,
show_operations=show_operations)
return self
def plot(
self,
kind: str = "scatter",
x_axis: Union[str, "Embedding"] = None,
y_axis: Union[str, "Embedding"] = None,
color: str = None,
show_ops: bool = False,
annot: bool = False,
):
"""
Handles the logic to perform a 2d plot in matplotlib.
Arguments:
kind: what kind of plot to make, can be `scatter`, `arrow` or `text`
x_axis: the x-axis to be used, must be given when dim > 2
y_axis: the y-axis to be used, must be given when dim > 2
color: the color of the dots
show_ops: setting to also show the applied operations, only works for `text`
annot: should the points be annotated
**Usage**
```python
from whatlies.embedding import Embedding
foo = Embedding("foo", [0.1, 0.3])
bar = Embedding("bar", [0.7, 0.2])
foo.plot(kind="arrow", annot=True)
bar.plot(kind="arrow", annot=True)
```
"""
if len(self.vector) == 2:
handle_2d_plot(
self,
kind=kind,
color=color,
show_operations=show_ops,
xlabel=x_axis,
ylabel=y_axis,
annot=annot,
)
return self
x_val = self > x_axis
y_val = self > y_axis
intermediate = Embedding(name=self.name,
vector=[x_val, y_val],
orig=self.orig)
handle_2d_plot(
intermediate,
kind=kind,
color=color,
xlabel=x_axis.name,
ylabel=y_axis.name,
show_operations=show_ops,
annot=annot,
)
return self
def plot(
self,
kind: str = "arrow",
x_axis: Union[int, "Embedding"] = 0,
y_axis: Union[int, "Embedding"] = 1,
axis_metric: Optional[Union[str, Callable, Sequence]] = None,
x_label: Optional[str] = None,
y_label: Optional[str] = None,
title: Optional[str] = None,
color: str = None,
show_ops: bool = False,
annot: bool = True,
axis_option: Optional[str] = None,
):
"""
Handles the logic to perform a 2d plot in matplotlib.
Arguments:
kind: what kind of plot to make, can be `scatter`, `arrow` or `text`
x_axis: the x-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
y_axis: the y-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
axis_metric: the metric used to project an embedding on the axes; only used when the corresponding
axis (i.e. `x_axis` or `y_axis`) is an `Embedding` instance. It could be a string
(`'cosine_similarity'`, `'cosine_distance'` or `'euclidean'`), or a callable that takes two vectors as input
and returns a scalar value as output. To set different metrics for x- and y-axis, a list or a tuple of
two elements could be given. By default (`None`), normalized scalar projection (i.e. `>` operator) is used.
x_label: an optional label used for x-axis; if not given, it is set based on `x_axis` value.
y_label: an optional label used for y-axis; if not given, it is set based on `y_axis` value.
title: an optional title for the plot.
color: the color of the dots
show_ops: setting to also show the applied operations, only works for `text`
annot: should the points be annotated
axis_option: a string which is passed as `option` argument to `matplotlib.pyplot.axis` in order to control
axis properties (e.g. using `'equal'` make circles shown circular in the plot). This might be useful
for preserving geometric relationships (e.g. orthogonality) in the generated plot. See `matplotlib.pyplot.axis`
[documentation](https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.axis.html#matplotlib-pyplot-axis)
for possible values and their description.
**Usage**
```python
from whatlies.embedding import Embedding
foo = Embedding("foo", [0.1, 0.3])
bar = Embedding("bar", [0.7, 0.2])
foo.plot(kind="arrow", annot=True)
bar.plot(kind="arrow", annot=True)
```
"""
if isinstance(axis_metric, (list, tuple)):
x_axis_metric = axis_metric[0]
y_axis_metric = axis_metric[1]
else:
x_axis_metric = axis_metric
y_axis_metric = axis_metric
x_val, x_lab = self._get_plot_axis_value_and_label(x_axis,
x_axis_metric,
dir="x")
y_val, y_lab = self._get_plot_axis_value_and_label(y_axis,
y_axis_metric,
dir="y")
x_label = x_lab if x_label is None else x_label
y_label = y_lab if y_label is None else y_label
emb_plot = Embedding(name=self.name,
vector=[x_val, y_val],
orig=self.orig)
handle_2d_plot(
emb_plot,
kind=kind,
color=color,
xlabel=x_label,
ylabel=y_label,
title=title,
show_operations=show_ops,
annot=annot,
axis_option=axis_option,
)
return self
def plot(
self,
kind: str = "arrow",
x_axis: Union[int, "Embedding"] = None,
y_axis: Union[int, "Embedding"] = None,
x_label: Optional[str] = None,
y_label: Optional[str] = None,
title: Optional[str] = None,
color: str = None,
show_ops: bool = False,
annot: bool = True,
axis_option: Optional[str] = None,
):
"""
Handles the logic to perform a 2d plot in matplotlib.
Arguments:
kind: what kind of plot to make, can be `scatter`, `arrow` or `text`
x_axis: the x-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
y_axis: the y-axis to be used, must be given when dim > 2; if an integer, the corresponding
dimension of embedding is used.
x_label: an optional label used for x-axis; if not given, it is set based on `x_axis` value.
y_label: an optional label used for y-axis; if not given, it is set based on `y_axis` value.
title: an optional title for the plot.
color: the color of the dots
show_ops: setting to also show the applied operations, only works for `text`
annot: should the points be annotated
axis_option: a string which is passed as `option` argument to `matplotlib.pyplot.axis` in order to control
axis properties (e.g. using `'equal'` make circles shown circular in the plot). This might be useful
for preserving geometric relationships (e.g. orthogonality) in the generated plot. See `matplotlib.pyplot.axis`
[documentation](https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.axis.html#matplotlib-pyplot-axis)
for possible values and their description.
**Usage**
```python
from whatlies.embedding import Embedding
foo = Embedding("foo", [0.1, 0.3])
bar = Embedding("bar", [0.7, 0.2])
foo.plot(kind="arrow", annot=True)
bar.plot(kind="arrow", annot=True)
```
"""
x_val, x_lab = self._get_plot_axis_value_and_label(x_axis, dir="x")
y_val, y_lab = self._get_plot_axis_value_and_label(y_axis, dir="y")
x_label = x_lab if x_label is None else x_label
y_label = y_lab if y_label is None else y_label
emb_plot = Embedding(name=self.name,
vector=[x_val, y_val],
orig=self.orig)
handle_2d_plot(
emb_plot,
kind=kind,
color=color,
xlabel=x_label,
ylabel=y_label,
title=title,
show_operations=show_ops,
annot=annot,
axis_option=axis_option,
)
return self