Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

Appearance settings

Latest commit

 

History

History
History
127 lines (103 loc) · 3.77 KB

File metadata and controls

127 lines (103 loc) · 3.77 KB
Copy raw file
Download raw file
Outline
Edit and raw actions
jupyter
jupytext kernelspec plotly
notebook_metadata_filter text_representation
all
extension format_name format_version jupytext_version
.md
markdown
1.1
1.1.1
display_name language name
Python 2
python
python2
description display_as has_thumbnail language layout name order page_type permalink thumbnail
Learn how to perform convolution between two signals in Python.
signal-analysis
false
python
base
Convolution
4
example_index
python/convolution/
/images/static-image

New to Plotly?

Plotly's Python library is free and open source! Get started by downloading the client and reading the primer.
You can set up Plotly to work in online or offline mode, or in jupyter notebooks.
We also have a quick-reference cheatsheet (new!) to help you get started!

Imports

The tutorial below imports NumPy, Pandas, SciPy and Plotly.

import plotly.plotly as py
import plotly.graph_objs as go
import plotly.figure_factory as ff

import numpy as np
import pandas as pd
import scipy

from scipy import signal

Import Data

Let us import some stock data to apply convolution on.

stock_data = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/stockdata.csv')
df = stock_data[0:15]

table = ff.create_table(df)
py.iplot(table, filename='stockdata-peak-fitting')

Convolve Two Signals

Convolution is a type of transform that takes two functions f and g and produces another function via an integration. In particular, the convolution $(f*g)(t)$ is defined as:

$$ \begin{align*} \int_{-\infty}^{\infty} {f(\tau)g(t - \tau)d\tau} \end{align*} $$

We can use convolution in the discrete case between two n-dimensional arrays.

sample = range(15)
saw = signal.sawtooth(t=sample)

data_sample = list(stock_data['SBUX'][0:100])
data_sample2 = list(stock_data['AAPL'][0:100])
x = list(range(len(data_sample)))
y_convolve = signal.convolve(saw, data_sample2)
x_convolve = list(range(len(y_convolve)))

trace1 = go.Scatter(
    x = x,
    y = data_sample,
    mode = 'lines',
    name = 'SBUX'
)

trace2 = go.Scatter(
    x = x,
    y = data_sample2,
    mode = 'lines',
    name = 'AAPL'
)

trace3 = go.Scatter(
    x = x_convolve,
    y = y_convolve,
    mode = 'lines',
    name = 'Convolution'
)

data = [trace1, trace2, trace3]
py.iplot(data, filename='convolution-of-two-signals')
from IPython.display import display, HTML

display(HTML('<link href="//fonts.googleapis.com/css?family=Open+Sans:600,400,300,200|Inconsolata|Ubuntu+Mono:400,700" rel="stylesheet" type="text/css" />'))
display(HTML('<link rel="stylesheet" type="text/css" href="http://help.plot.ly/documentation/all_static/css/ipython-notebook-custom.css">'))

! pip install git+https://github.com/plotly/publisher.git --upgrade
import publisher
publisher.publish(
    'python-Convolution.ipynb', 'python/convolution/', 'Convolution | plotly',
    'Learn how to perform convolution between two signals in Python.',
    title='Convolution in Python | plotly',
    name='Convolution',
    language='python',
    page_type='example_index', has_thumbnail='false', display_as='signal-analysis', order=4)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.