pythonot.github.io/master/_modules/ot/plot.html at master · PythonOT/pythonot.github.io

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

<!DOCTYPE html>

<head>

<title>ot.plot — POT Python Optimal Transport 0.9.8.dev documentation</title>

</head>

POT Python Optimal Transport

</a>

</form>

</div>

</div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">

<ul>

<li class="toctree-l1"><a class="reference internal" href="../../index.html">POT: Python Optimal Transport</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../auto_examples/plot_quickstart_guide.html">Quickstart Guide</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../auto_examples/index.html">Examples gallery</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../user_guide.html">User guide</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../all.html">API and modules</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../releases.html">Releases</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../contributors.html">Contributors</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../contributing.html">Contributing to POT</a></li>

<li class="toctree-l1"><a class="reference internal" href="../../code_of_conduct.html">Code of conduct</a></li>

</ul>

</div>

</nav>

<a href="../../index.html">POT Python Optimal Transport</a>

</nav>

<li class="breadcrumb-item"><a href="../index.html">Module code</a></li>

</li>

</ul>

<hr/>

</div>

<h1>Source code for ot.plot</h1><div class="highlight"><pre>

"""

Functions for plotting OT matrices

.. warning::

Note that by default the module is not import in :mod:`ot`. In order to

use it you need to explicitly import :mod:`ot.plot`

"""

# Author: Remi Flamary <remi.flamary@unice.fr>

#

# License: MIT License

import numpy as np

import matplotlib.pylab as pl

from matplotlib import gridspec

from . import backend

from scipy.sparse import issparse, coo_array

def plot1D_mat(

a,

b,

M,

title="",

plot_style="yx",

a_label="",

b_label="",

color_source="b",

color_target="r",

coupling_cmap="gray_r",

):

r"""Plot matrix :math:`\mathbf{M}` with the source and target 1D distributions.

Creates a subplot with the source distribution :math:`\mathbf{a}` and target

distribution :math:`\mathbf{b}`.

In 'yx' mode (default), the source is on the left and

the target on the top, and in 'xy' mode, source on the bottom (upside

down) and the target on the left.

The matrix :math:`\mathbf{M}` is shown in between.

Parameters

----------

a : ndarray, shape (na,)

Source distribution

b : ndarray, shape (nb,)

Target distribution

M : ndarray, shape (na, nb)

Matrix to plot

title : str, optional

Title of the plot

plot_style : str, optional

Style of the plot, 'yx' or 'xy'. 'yx' places the source on the left and

the target on the top, 'xy' places the source on the bottom (upside

down) and the target on the left.

a_label : str, optional

Label for source distribution

b_label : str, optional

Label for target distribution

color_source : str, optional

Color of the source distribution

color_target : str, optional

Color of the target distribution

coupling_cmap : str, optional

Colormap for the coupling matrix

Returns

-------

ax1 : source plot ax

ax2 : target plot ax

ax3 : coupling plot ax

See Also

--------

:func:`rescale_for_imshow_plot`

"""

assert plot_style in ["yx", "xy"], "plot_style should be 'yx' or 'xy'"

na, nb = M.shape

gs = gridspec.GridSpec(

3, 3, height_ratios=[1, 1, 1], width_ratios=[1, 1, 1], hspace=0, wspace=0

)

xa = np.arange(na)

xb = np.arange(nb)

# helper function for code factorisation

def _set_ticks_and_spines(ax, empty_ticks=True, visible_spines=False):

if empty_ticks:

ax.set_xticks(())

ax.set_yticks(())

ax.spines["top"].set_visible(visible_spines)

ax.spines["right"].set_visible(visible_spines)

ax.spines["bottom"].set_visible(visible_spines)

ax.spines["left"].set_visible(visible_spines)

if plot_style == "xy":

# horizontal source on the bottom, flipped vertically

ax1 = pl.subplot(gs[2, 1:])

ax1.plot(xa, np.max(a) - a, color=color_source, linewidth=2)

ax1.fill(

xa,

np.max(a) * np.ones_like(a),

color=color_source,

alpha=0.5,

)

ax1.set_title(a_label, y=-0.15)

# vertical target on the left

ax2 = pl.subplot(gs[0:2, 0])

ax2.plot(b, xb, color=color_target, linewidth=2)

ax2.fill(b, xb, color=color_target, alpha=0.5)

ax2.invert_xaxis()

ax2.invert_yaxis()

ax2.set_title(b_label)

_set_ticks_and_spines(ax1, empty_ticks=True, visible_spines=False)

_set_ticks_and_spines(ax2, empty_ticks=True, visible_spines=False)

# coupling matrix in the middle

ax3 = pl.subplot(gs[0:2, 1:], sharey=ax2, sharex=ax1)

ax3.imshow(M.T, interpolation="nearest", origin="lower", cmap=coupling_cmap)

ax3.set_title(title)

_set_ticks_and_spines(ax3, empty_ticks=False, visible_spines=True)

pl.subplots_adjust(hspace=0, wspace=0)

return ax1, ax2, ax3

else: # plot_style == 'yx'

# vertical source on the left

ax1 = pl.subplot(gs[1:, 0])

ax1.plot(a, xa, color=color_source, linewidth=2)

ax1.fill(a, xa, color=color_source, alpha=0.5)

ax1.invert_xaxis()

ax1.set_title(a_label)

# horizontal target on the top

ax2 = pl.subplot(gs[0, 1:])

ax2.plot(xb, b, color=color_target, linewidth=2)

ax2.fill(xb, b, color=color_target, alpha=0.5)

ax2.set_title(b_label)

# coupling matrix in the middle

ax3 = pl.subplot(gs[1:, 1:], sharey=ax1, sharex=ax2)

ax3.imshow(M, interpolation="nearest", cmap=coupling_cmap)

# Set title below matrix plot

ax3.text(

0.5,

-0.025,

title,

ha="center",

va="top",

transform=ax3.transAxes,

fontsize="large",

)

return ax1, ax2, ax3</div>

def rescale_for_imshow_plot(x, y, n, m=None, a_y=None, b_y=None):

r"""

Gives arrays xr, yr that can be plotted over an (n, m)

imshow plot (in 'xy' coordinates). If `a_y` or `b_y` is provided,

y is sliced over its indices such that y stays in [ay, by].

Parameters

----------

x : ndarray, shape (nx,)

y : ndarray, shape (nx,)

n : int

x-axis size of the imshow plot on which to plot (x, y)

m : int, optional

y-axis size of the imshow plot, defaults to n

a_y : float, optional

Lower bound for y

b_y : float, optional

Upper bound for y

Returns

-------

xr : ndarray, shape (nx,)

Rescaled x values (due to slicing, may have less elements than x)

yr : ndarray, shape (nx,)

Rescaled y values (due to slicing, may have less elements than y)

See Also

--------

:func:`plot1D_mat`

"""

# slice over the y values that are in the y range

a_x, b_x = np.min(x), np.max(x)

assert x.shape[0] == y.shape[0], "x and y arrays should have the same size"

if a_y is None:

a_y = np.min(y)

if b_y is None:

b_y = np.max(y)

if m is None:

m = n

idx = (y >= a_y) & (y <= b_y)

x_rescaled = (x[idx] - a_x) * (n - 1) / (b_x - a_x)

y_rescaled = (y[idx] - a_y) * (m - 1) / (b_y - a_y)

return x_rescaled, y_rescaled</div>

def plot2D_samples_mat(xs, xt, G, thr=1e-8, **kwargs):

r"""Plot matrix :math:`\mathbf{G}` in 2D with lines using alpha values

Plot lines between source and target 2D samples with a color

proportional to the value of the matrix :math:`\mathbf{G}` between samples.

Supports both dense and sparse matrices. For sparse matrices, automatically

detects the format and efficiently iterates only over non-zero entries.

Parameters

----------

xs : ndarray, shape (ns,2)

Source samples positions

xt : ndarray, shape (nt,2)

Target samples positions

G : ndarray or sparse matrix, shape (ns,nt)

OT matrix (dense array, scipy.sparse matrix, or backend array)

thr : float, optional

threshold above which the line is drawn

**kwargs : dict

parameters given to the plot functions (default color is black if

nothing given)

"""

if ("color" not in kwargs) and ("c" not in kwargs):

kwargs["color"] = "k"

scale = kwargs.pop("alpha", 1)

# Convert to numpy/scipy format for plotting

try:

nx = backend.get_backend(G)

if nx.issparse(G):

# Backend sparse -> extract as numpy arrays for COO format

rows, cols, data = nx.sparse_coo_data(G)

rows = nx.to_numpy(rows).astype(int)

cols = nx.to_numpy(cols).astype(int)

data = nx.to_numpy(data)

is_sparse = True

else:

# Backend dense -> convert to numpy

G = nx.to_numpy(G)

is_sparse = False

except (ValueError, AttributeError):

# Not a backend array, check if scipy.sparse

is_sparse = issparse(G)

if is_sparse:

G_coo = G if isinstance(G, coo_array) else G.tocoo()

rows, cols, data = G_coo.row, G_coo.col, G_coo.data

if is_sparse:

# Sparse: iterate over non-zero entries only

mx = data.max() if len(data) > 0 else 1.0

for i, j, val in zip(rows, cols, data):

if val / mx > thr:

pl.plot(

[xs[i, 0], xt[j, 0]],

[xs[i, 1], xt[j, 1]],

alpha=val / mx * scale,

**kwargs,

)

else:

# Dense: iterate over all entries

mx = np.max(G)

for i in range(xs.shape[0]):

for j in range(xt.shape[0]):

if G[i, j] / mx > thr:

pl.plot(

alpha=G[i, j] / mx * scale,

**kwargs,

)</div>

</pre></div>

</div>

<hr/>

</div>

Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a

<a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>

provided by <a href="https://readthedocs.org">Read the Docs</a>.

</footer>

</div>

</section>

</div>

<div class="rst-versions" data-toggle="rst-versions" role="note"

aria-label="versions">

<!-- add shift_up to the class for force viewing ,

data-toggle="rst-current-version" -->

Python Optimal Transport 0.9.8.dev

<!-- versions

-->

<span class="rst-current-version" style="display: inline-block;padding:

0px;color:#fcfcfcab;float:left;font-size: 100%;">

Versions:

<a href="https://pythonot.github.io/"

style="padding: 3px;color:#fcfcfc;font-size: 100%;">Release</a>

<a href="https://pythonot.github.io/master"

style="padding: 3px;color:#fcfcfc;font-size: 100%;">Development</a>

<a href="https://github.com/PythonOT/POT"

style="padding: 3px;color:#fcfcfc;font-size: 100%;">Code</a>

<!--

<dl>

<dt>Versions</dt>

<dd><a href="https://pythonot.github.io/">Release</a></dd>

<dd><a href="https://pythonot.github.io/master">Development</a></dd>

<dt><a href="https://github.com/PythonOT/POT">Code on Github</a></dt>

</dl>

<hr>

</div>

</div>-->

</div><script>

jQuery(function () {

SphinxRtdTheme.Navigation.enable(true);

});

</script>

</body>

</html>

FilesExpand file tree

plot.html

Latest commit

History

plot.html

File metadata and controls