Exploring the Parameter Space¶
Expand models to check the full range of inputs and see how it impacts the outputs.
Resources¶
Introduction to Parameter Exploration¶
Notes¶
If you’ve merely done a calculation, you have a single answer and can’t learn any more about the problem without redoing the calculations
Instead because we are building models which can flexibly take any input and convert that into the appropriate output, it opens up a lot of possible extensions to the model
This is our main focus for a large portion of the course: how can we extend any financial model to get a greater understanding of the underlying problem
Sensitivity analysis is useful to understand how the full range of possible inputs affects the main results of your model
Scenario analysis allows analyzing outcomes in example situations
Monte Carlo Simulation allows assigning outputs to a probability distribution, which helps you understand the risk of your result
Transcript¶
- hey everyone
- nick diabetis here teaching you
- financial modeling and today we're going
- to be talking about
- exploring the parameter space through
- sensitivity analysis
- so this is our first lecture out of this
- segment and this segment is really
- focused on
- we've built out a basic model now how do
- we get a deeper understanding
- of the problem than what the initial
- model
- says so
- so far you take some inputs
- you put them into your model and you get
- some outputs
- but that's just kind of one picture of
- what could happen
- based on the initial values of those
- inputs
- and certainly you can kind of change
- around the inputs and see what happens
- to the outputs but that's not a very
- systematic way
- of looking at the different values that
- there could be
- for the inputs um
- we can get a much deeper understanding
- of
- the whatever situation that we're
- modeling if
- we really explore all the different
- possible values that the inputs
- could be and how that affects the output
- from the model so that's
- one of the big reasons why i've been
- really emphasizing that
- in a model everything has to be linked
- together from the inputs all the way to
- the outputs
- changing your inputs should make a
- change in your outputs
- and you shouldn't have to be redoing a
- bunch of manual steps to get there if
- you just kind of hard code everything
- that's just a calculation and not a
- model
- because it's rigid and you can't change
- around
- the inputs and see how the outputs
- change in response to that
- and when you just do a calculation you
- get one answer
- and it's for a certain set of inputs
- maybe they're reasonable maybe they're
- not but when you build a model
- you set it up so it can take any inputs
- and so all of a sudden you're able to
- do much more exploration of the
- possibilities
- of the real world and incorporate that
- into your decision making
- so here's a quick visualization of
- what we're going to be doing with
- parameter expiration
- so the basic concept is we're going to
- run the model
- multiple times we're going to give the
- model different inputs
- each time and we're going to collect the
- outputs
- from each of those runs of the model and
- keep those associated with whatever
- inputs
- cause the outputs and then we're going
- to take all these
- uh inputs outputs all that information
- and put it into some kind of
- visualization that is easier to
- understand
- than the wrong numbers because very
- quickly this becomes a lot of numbers to
- deal with
- and so it's very difficult to parse
- through all that
- as the reader of the model unless
- there's an effective
- visualization to tie it all together
- so we'll talk about three different ways
- in this class
- to explore the the parameters or the
- inputs to the model
- and how those affect the outputs so the
- first one
- that we're going to be looking at in
- this lecture is sensitivity analysis
- we are also going to cover scenario
- analysis
- and monte carlo simulation as the other
- two methods
- so the differences between the three so
- sensitivity analysis
- um we're going to look at basically the
- full range of inputs that we think
- are reasonable for the model and see
- what full range of
- outputs we can get from that so in a lot
- of ways it's a good way to kind of
- stress your model
- and see if we take things all the way to
- uh
- as far as these inputs could reasonably
- go
- what happens to our outcome um
- whereas uh the other methods we have
- scenario analysis and monte carlo
- simulations so scenario analysis
- is about as the name implies trying to
- come up with specific
- realistic scenarios and building those
- into your model
- so very commonly that might be something
- like a
- good economy normal economy bad economy
- scenario
- and try to set all the values of the
- inputs to align
- with whatever the situation is and so
- you get a few different realistic
- outcomes
- out of your model under different
- conditions
- and then the the third
- [Music]
- that we're looking at is monte carlo
- simulation
- and monte carlo simulation is
- similar to uh sensitivity analysis
- and that we're throwing a bunch of
- different inputs at the model
- not only just a certain few that we've
- chosen
- for scenario analysis
- what the difference with monte carlo
- simulation is is that
- the inputs are actually random you set
- probability distributions for each of
- the inputs
- and each run of the model the inputs are
- drawn from those probability
- distributions randomly and then you take
- all these
- randomized values of the inputs pass
- them into the model
- and you get your output and what that
- allows you to do is you can actually get
- a probability distribution of the
- outputs from the model as well
- which can give you a good understanding
- of the risk
- of your result so
- let me give kind of a concrete example
- of using all three of these methods
- because
- they are similar to some extent and a
- lot of students wonder why
- why do we do all three why why is one
- not enough
- so you could think about um
- a capital budgeting model where you've
- got some project
- you have some initial investment on the
- project and then
- that project produces some cash flows
- and ultimately
- you're going to calculate an mpv of this
- project as a result
- and use that mpv to decide whether to
- take on the project
- so you've built out your model you've
- got the basic result
- and say you you've got a positive mpv
- and so it looks like okay
- we want to take this project but let's
- try to get a little better understanding
- of it before we jump the gun on that
- so then you can do uh sensitivity
- analysis
- and sensitivity analysis you can say
- well uh let's look at the full range of
- what's reasonable for the discount rate
- uh maybe it's as low as four percent but
- maybe it's as high as
- 12 and then uh you kind of space out
- you know try four five six seven eight
- nine ten twelve
- and see what npv comes out
- when you use all these different
- discount rates and there you may see
- oh well our baseline discount rate of
- seven percent it was mbv positive
- but really if it goes up to nine percent
- all of a sudden
- the npv is negative so we need to really
- carefully consider
- the discount rate have we accurately
- estimated the discount rate or is it
- really higher
- if it's higher all of a sudden this
- becomes not so
- attractive
- then thinking about scenario analysis we
- can go again with the example of the bad
- economy
- good economy normal economy cases
- so you might say that in the good
- economy
- you're gonna have higher demand uh
- it's going to be um
- a lower discount rate because it's
- easier to raise capital
- um and just kind of lining up all the
- different inputs into the model
- what all makes sense in a good economy
- putting that all together
- running the model and you get your good
- economy and pv
- and then you do the same thing for bad
- economy okay now it's going to be high
- discount rate we're going to have low
- demand
- um and so now we get our bad economy mpv
- so then you can understand uh with these
- kind of realistic scenarios
- well this this model says we got
- positive mpv
- in the normal in the good economy case
- but if the economy goes bad
- all of a sudden this is not an mpv
- positive project anymore so then you
- have to think about
- you know what's the chance of us going
- into a recession
- if it's high enough then maybe we don't
- actually take this project
- then lastly we have monte carlo
- simulation
- and for monte carlo simulation we assign
- distributions
- to each of these inputs so that's saying
- maybe okay the discount rate is
- seven percent by default
- but we're going to say now it is drawn
- from a normal distribution
- with a mean of seven percent and
- standard deviation
- of two percent so one time you run the
- model you may get seven percent another
- time you make it nine you may get eleven
- you may get four
- et cetera each time you run the model
- it's pulling a different value based off
- that normal distribution
- and you do the same thing for all the
- other inputs you do that for the demand
- uh whatever other inputs are going into
- the model
- all them now have probability
- distributions and then you go and you
- run this model
- a lot of times usually a thousand or ten
- thousand times
- um and you get all the mpvs out as a
- result
- and so what that gets you as long as you
- picked
- reasonable distributions for your inputs
- you now have a good estimate of the
- distribution of your mpv
- so that allows you to say oh well even
- though the baseline mpv is positive
- maybe uh through that analysis you can
- determine that it's actually a high risk
- project where on average
- the mpv is positive but ninety percent
- of the time it actually ends up negative
- it's only in those ten percent of the
- time that you have a very high mpv and
- it makes up for it and that allows the
- average to be positive
- but the majority of the time it's a
- negative mpv project
- so then that um really comes into the
- decision-making process
- of how much risk are we willing to take
- on with this project
- do we have plenty of sufficient capital
- such that it doesn't matter if this
- project fails
- okay well then yeah we can go with uh
- it's positive mpv let's take it
- but if you're capital constrained
- all of a sudden it becomes a more
- difficult decision because of the large
- risk
- involved in the project so all of these
- different considerations
- you would not have gotten by just
- building out the initial capital
- budgeting model
- it's only through exploring the
- parameter space
- with these different methods that we can
- get a much much richer understanding of
- the problem that we're trying to solve
- so next time we're going to come back
- and get into
- the theory of sensitivity analysis and
- what it looks like to carry that out so
- thanks for listening
- and see you next time
Introduction to Sensitivity Analysis¶
Notes¶
The formal definition of sensitivity analysis may seem complicated, but all we are doing is running the model multiple times with different inputs and showing the outputs
A key component of sensitivity analysis is the visualization, as now that there are many different outputs it is much easier to draw meaning from them when visualized
Transcript¶
- hey everyone
- nick duraburtis here teaching you
- financial modeling today we're going to
- be
- talking about an introduction to
- sensitivity analysis
- this is part of our lecture segment on
- exploring the parameter space
- so we introduced last time
- what exploring the parameter space means
- basically
- trying a bunch of different inputs in
- our model and looking at
- how that affects all the outputs and
- trying to
- gain a deeper understanding of the
- problem that we're modeling
- through that process so
- sensitivity analysis is one of the three
- approaches we're looking at
- in this course along with scenario
- analysis and monte carlo simulation
- and we're going to dig into formally
- what sensitivity analysis
- is so
- as with all the methods the general
- process is
- we're running the model a bunch of
- different times with different inputs
- uh and we're gonna get the outputs from
- each of those runs
- keep them all linked together and then
- visualize all that
- at the end that's true for all the three
- approaches
- but there are uh differences with each
- of the approaches and how they're
- carried out
- so for sensitivity analysis
- here would be the formal definition
- and just reading this it may look scary
- but really it's just a process that you
- have to follow
- and it's fairly straightforward once we
- actually get into how to apply it
- it just looks a little bit more
- complicated in like
- math and algorithmic terms
- so what we're doing in sensitivity
- analysis
- is for each one of the inputs
- we're going to choose a set of possible
- values for that input
- so say it's interest rate you might say
- it could be anywhere from three to ten
- percent three four five six seven eight
- nine ten percent
- those would be your values and you would
- want to do that for
- multiple different inputs uh whatever
- uh makes sense to analyze in your
- problem
- step two is then to
- look at all the different ways that you
- can combine each of these input values
- so formally that's called a cartesian
- product
- and that just means so say let's let's
- make a little bit smaller and say you're
- looking at
- five six seven percent interest rate and
- then
- uh we're going to look at uh
- demand of a thousand units
- five thousand units ten thousand units
- so it would be the
- five percent rate with the thousand
- uh demand and then the five percent rate
- with the five thousand demand and then
- the five percent rate went to ten
- thousand demand
- and then the six percent rate which
- either with each of the three demands
- and
- the seven percent rate which the with
- each of the three demands
- so nine uh sets of inputs all together
- for three of the interest rate and three
- of the demand so however many values of
- each of the inputs
- if you just multiply the number together
- that should be how many
- runs of the model you have in the end
- sets of inputs and
- outputs so
- you've got all those values combined
- together
- so then step three is to run the model
- and it's saying just run the model
- for each one of these different sets of
- inputs
- then step four is as you're running the
- model
- store the output from the model along
- with
- the inputs since we're running it so
- many different times with different
- inputs
- you got to keep everything linked
- together and then number five here
- is then to visualize the results
- so we have a bunch of numbers coming out
- we have to make that more easily
- understandable
- and so we do that through visualization
- so hopefully just talking through it
- made that a little bit more concrete but
- let's look at an actual example problem
- and how we would apply it
- to go even further in that concrete
- direction
- so let's keep talking about demand here
- we have a simple demand model so the
- entire
- model is a single equation here just
- demand
- equals the constant minus the elasticity
- of demand times the price and that's
- kind of a standard demand equation
- so here we had on this slide x's are
- our inputs right and so here x is going
- to be
- the demand constant the elasticity of
- demand and the price those are our three
- inputs
- into the demand model and the output of
- course is the demand
- itself so
- let's go through those five steps now or
- at least the first four
- so the first step uh is
- to choose values of each of these inputs
- that we want to look at whatever is the
- range of reasonable values
- for the inputs you typically want to go
- for whatever the full
- range of reasonable values are take kind
- of the lowest
- and the highest values that you think
- would be reasonable to see in the real
- world and then you can see the whole
- range between them
- so here uh just taking two demand
- constants to
- elasticities and two prices
- and those are our values we're going to
- use in the sensitivity analysis
- then step number two in that cartesian
- product
- or in simpler terms just combining all
- the inputs in every way that you can
- and so we get that table there at the
- bottom
- so it has for the 60 000
- uh demand constant we're going to see
- every other possible combination of
- input values it's with both the 200 and
- the 500
- it's with both the 50 and 100 and so we
- have all those combinations
- same thing for the hundred thousand
- domain constant and you can see that
- we've got it right because we've got two
- of each input
- two of each input and so it's two times
- two times two
- is eight total input cases and that's
- indeed what we have here
- so then going to step three is to run
- the model
- and step four is to keep those things
- linked together so we can kind of do all
- that
- here in this table and now we have
- calculated this equation for each one of
- these
- sets of inputs and by using this table
- we've kept them
- mapped together which inputs go to which
- output so
- that was our whole sensitivity analysis
- process right there
- really not complicated the only
- remaining step
- is then to visualize that it's kind of
- hard to just
- look at this and be able to extrapolate
- meaning out of it
- immediately because it's a bunch of
- numbers so we're going to look at ways
- we can
- make this easily understandable to where
- you can just glance at it
- and immediately see uh
- meaning out of the out of those large
- amounts of numbers
- so we'll come back and actually
- visualize that
- when we look at the applied examples in
- excel and python
- and that's going to be the focus of the
- next lecture video is to actually
- implement sensitivity analysis in excel
- so thanks for listening and see you next
- time
Sensitivity Analysis in Excel¶
Notes¶
Data tables in Excel allow calculating a cell multiple times, changing some other cell. This is perfect for sensitivity analysis if we target an output cell and change an input cell
One-way data tables change one input at a time, two-way data tables change two inputs at a time
You are basically limited to changing two inputs at once, without doing some clever hacks
Visualization rule of thumb: graph one-way data tables and use conditional formatting for two-way
Conditional formatting changes the format of cells based on conditions, such as putting the largest numbers in green and the smallest in red
Row input cell means that your inputs are going horizontally in a row. Column input cell means that your inputs going vertically in a column. For one-way data tables, you will use only one of the two. For two-way data tables, you will use both
Resources¶
Transcript¶
- hey everyone
- nick derbert is here teaching you
- financial modeling and today
- we're going to be looking at how to do
- sensitivity analysis
- in excel this is part of our lecture
- segment
- on exploring the parameter space with
- sensitivity analysis
- so in the last segment we went through
- all the
- theory behind sensitivity analysis and
- everything that's involved and kind of a
- simple example on how to do that
- now let's look at how we actually
- operationalize that in excel
- so excel has a nice built-in tool called
- a data table
- which makes this process fairly easy for
- us
- so a data table lets you look at the
- value
- of some cell while changing
- some different cells and so you can look
- at the value of an output
- of your model while changing around the
- inputs
- of your model without you having to go
- in and manually change those out
- and with data tables we have
- two different ways we can go about it
- one is a one-way data table and the
- other is a two-way data table
- so with a two-way data table we're
- looking at two different inputs at once
- and changing each of these two inputs
- and kind of the intersection
- of all those different
- outputs or runs of the model which
- produce those outputs
- and with the one-way data table we're
- looking only at a single
- input at once
- and that is sort of a limitation in
- excel
- that you basically can only really look
- at
- two variables at the same time in the
- analysis
- but it gets difficult to visualize more
- than two variables at once anyway
- so it's not a huge limitation
- even though uh it can be frustrating if
- you want to look at more
- variables you find yourself doing a lot
- of manual steps
- there is a way to to hack it into
- doing more than two variables at once if
- basically one of your variables
- was something like an identifier to
- do a vlookup on another table which has
- the real inputs
- you could set up something like that but
- that's a lot of effort
- and generally you're just going to be
- looking at
- two variables at once as a maximum in
- excel
- and you access this from the data tab
- and then what if analysis and then
- data table and then it asks for two
- inputs
- you're going to give it the row input
- cell that's any inputs you have going
- horizontally in a row
- and a column input cell that's any
- inputs you have
- going vertically down in a column and if
- it's a one-way data table you're only
- going to have one of the two filled in
- if it's two-way data table you're gonna
- have both filled in
- and we'll see that uh more precisely in
- an example here in a minute
- and then thinking about how we can
- visualize the results
- so there's two main ways
- in general to visualize sensitivity
- analysis
- and that's true for excel as well
- is that two approaches are graphing
- and conditional formatting so
- uh my rule of thumb is if it's a one-way
- data table you're looking at one
- variable at once
- a graph is going to be more effective
- and if you're looking at
- two variables that wants a two-way data
- table then
- conditional formatting is going to be
- the more effective approach
- that's not to say that you couldn't use
- conditional formatting with a one-way
- and you couldn't do a graph of a two-way
- but generally i think it makes the most
- sense to do it that way
- so here's an example of conditional
- formatting
- conditional formatting is just applying
- formatting to cells
- based on some conditions and what we're
- going to look at in this context
- is giving colors to higher and lower
- values
- so you can see in this table that the
- high values are red
- and the low values are green and that
- makes it very easy to just quickly look
- at this
- and understand where the higher and
- lower parts of this table are
- and that's going to be really useful for
- understanding the results of our
- sensitivity analysis
- so let's go ahead and work on an example
- so i'll be starting from the existing
- dynamic salary retirement model
- and now i'm going to be adding
- sensitivity analysis
- to it so uh
- and you can find the completed example
- of this on the course
- site which has everything in there
- already
- so let's first say what if
- the savings rate was different it's 25
- of course we can go in and we can change
- it and we can see the result of that
- but we want to have the values across a
- bunch of different
- values of saving rates we want to see
- all the years for retirement all at once
- in the model
- without having to go in and change the
- input values
- so we can do that with a data table
- so the first thing that we'll do to
- build out the data table
- is first you want to reference whatever
- cell it is that has the output
- that you're trying to look at you can
- only look at one output at once
- in a data table and so you may have to
- have multiple if you have multiple
- outputs from your model
- here we just have years to retirement as
- our output from the model so i'm going
- to reference that over to this cell
- then um we want to put the values of the
- inputs that we want to look at so that's
- the
- the step one and the formal sensitivity
- analysis process
- thinking about all the different values
- of the inputs we want to look at
- so for savings rate let's say let's
- start it at five percent and go up to 70
- percent
- in five percent increments so in excel
- once you type out
- uh two numbers they can
- deduce the pattern from that and keep
- increasing it from there
- so if you drag it then we'll continue to
- get five percent
- increments after that
- so now we have the setup to be able to
- create the
- data table and this is a one-way data
- table because we're looking at only
- one input at once and
- so we highlight the entire range here
- you want to make sure that you get
- the output cell as well as all of the
- inputs
- and you want to make sure that your
- output is to the right
- of all your inputs assuming you're doing
- a vertical
- one-way data table and so we highlight
- all this
- and then we can go to the data tab
- and then to what-if analysis
- and then to data table and that's when
- it pops up this thing which asks about
- the row input cell and the column input
- cell
- and for the one-way data table we're
- only going to fill in one of those
- so our inputs are arranged in a column
- and so we're going to use the column
- input cell and the cell that we want to
- target
- is the cell which contains the value of
- the input that we're trying to change
- here we're talking about the savings
- rate and so i'm going to
- reference the savings rate for the
- column
- input cell and that's it then once i hit
- ok
- we've got our results here so if you're
- able to save
- seventy percent every year your years
- retirement would drop from the baseline
- 28 down to 17 years
- so that's a huge difference and then if
- you
- were able to save less it's gonna take
- substantially longer to retire as well
- um so then we
- would want to label this savings rate
- so it's clear what we're actually
- changing here
- um and we can
- uh put a uh merge
- sell here years retirement
- versus savings rate
- and wrap the text on that
- so now we've got nice table
- and you would want to you know apply
- some coloring to this
- and put nice borders around it and
- everything
- i'm going to leave it there for now you
- can look at the completed example for
- the full formatting on it
- but one other thing i do want to mention
- which is
- helpful for these sata tables is we do
- have to have this reference cell here
- but there's no actual uh calculation
- going here this is the baseline result
- so it's helpful to hide this because
- it's just kind of distracting
- and so i usually just go ahead and make
- the text for that
- white so that it hides that cell even
- though it has to be there
- and now we just see each of the values
- with
- uh the input
- so then to visualize this i mentioned
- that graphs make a lot of sense
- for one-way data tables so let's go
- ahead and insert and go to recommended
- charts and we can pick an appropriate
- chart type for this
- and this is going to be the
- years retirement
- versus the savings rate
- uh we would want to add access titles
- this is the savings rate
- this is the years for retirement
- and then it's very easy to see that
- of course as we save more we're able to
- retire quicker
- but also you can see that the initial
- changes in the savings rate
- have a greater impact than the later
- changes in the savings rate
- it looks sort of exponential here and
- then as you get
- further out it looks more linear
- and so going from a ten percent to a
- twenty percent
- savings rate is a much bigger impact
- than going from a sixty savings rate to
- a 70
- savings rate and it's not very clear
- just looking at the numbers to draw that
- conclusion
- but looking at the graph it becomes very
- clear
- another thing which you might have
- noticed already
- but becomes even more clear in the graph
- is that it caps out at 40 and that seems
- incorrect um why is there no difference
- between five and ten percent
- savings rate seems like it should keep
- going up and it should
- uh the issue is that our model is
- actually capped at 40 years
- and so it's maxed out the model here and
- so
- if you did really need to evaluate five
- and ten percent savings rate you would
- then want to expand
- out the model so um sensitive analysis
- is really helpful for kind of stressing
- your model
- at the far ends and seeing if it can
- handle the inputs that you're throwing
- at it
- so that's the one-way data table now
- let's look
- at a two-way data table so let's keep
- working with the savings rate but now
- let's also change the
- uh how often we're getting the
- promotions
- in the same analysis so we can take the
- same savings rates
- those were fine savings rates to use
- and now we want to also line up the
- values that we want to look at
- for how often the promotions occur so
- we can just go up one by one and you can
- drag those to go
- all the way let's go out every 10 years
- and now you can see kind of a table
- starting to form here
- and whereas with the one-way data table
- we put the uh output we want to look at
- reference to up and to the right
- of our first input here
- the output is going to go right here
- it's going to go in this empty cell
- in between our column and our row input
- here we're going to reference the year's
- retirement
- so then now we have the setup to where
- we can create
- the two-way data table so if i highlight
- this entire range
- now i can go again to data what-if
- analysis
- data table and now that it's a two-way
- data table i'm going to fill in
- both of these and so the the numbers
- the input which is going in a row is the
- promotions every n years and then the
- input that's going in the column
- is the savings rate and then when i hit
- okay it will calculate the model a whole
- bunch of times
- for us so now we've got
- 14 times 9 different runs of the model
- all together without having to go and
- manually change out those
- inputs but you just look at this thing
- you know you can
- kind of see looking at it for a while
- okay lower values are over here
- higher values are over here but
- it's not so easy to just immediately get
- meaning out of that
- so the next step is then to add the
- conditional
- formatting so for conditional formatting
- it's on the home
- tab right here conditional formatting
- and there are a lot of things you can do
- with it but here we're just going to
- focus on the
- color scales and you can hover over the
- color scales to see what it's going to
- look like
- and i like to use the red and green
- color scales
- because people just intuitively
- associate green with good
- and red with bad if they're put together
- and so
- it makes a lot of sense whatever is
- uh whatever direction uh
- higher or lower is good in your model
- you would make that green
- and uh vice versa for red
- so here um looking at this first one
- it's actually highlighting the higher
- years to retirement in green
- but a low number of years until
- retirement is a good thing
- and so we want to go to this second
- color map and
- then we have the uh high years to
- retirement highlighted in red
- and the low years to retirement
- highlighted in
- green so
- then we can see now at a very easy
- glance
- uh where the low and high years to
- retirement are
- and that
- if you uh and we also see again this
- issue of it kind of maxing out the model
- in all these five and ten percent cases
- um so then you would want to add a
- little bit more
- formatting to this you would want to put
- labels promotions
- every number of years
- and we can then merge that
- and we would want to um
- merge over here as well and this can be
- the savings rate
- and to get that going vertically we can
- go into format cells
- change the alignment to 90 degrees
- and then center that
- and let's uh put that
- there and we can bold these things
- and then you know you would want to
- [Music]
- throw your title up here
- so this is going to be the ears to
- retirement
- or savings rate versus promotions
- every number of years
- and then we have our data table
- um so
- and then just like with the one-way data
- table
- i like to hide this cell because it's
- not
- anything meaningful for us so i just
- make that white
- and then we're left with just what we
- actually want to see
- um and again you would want to apply
- some coloring to the rest of this
- to make it kind of stand out as a table
- and you can see the full formatting of
- that
- in the completed excel example
- but that's that's the idea here of how
- to do a one-way data table
- with visualization and a two-way data
- table
- with visualization in excel
- and the lab exercise for
- this portion of the lecture is then to
- do this for your own project one
- model um so take your excel model from
- project one
- and you're going to um
- probably make a copy of it just in case
- something you mess up something
- but then you're going to implement a
- similar kind of analysis to what i just
- did
- so you're going to add a one-way
- data tables as well as a two-way data
- table looking at
- how the mpv changes in response to
- changing the number of machines
- and the initial demand so one way data
- table for each of those as well as a
- graph
- for each of those and then a two-way
- data table with conditional formatting
- looking at both at the same time
- so that sensitivity analysis in excel
- next time we're going to come back and
- cover some
- extra python basics before we can get
- into doing
- sensitivity analysis in python so
- thanks for listening and see you next
- time
Using Python Dictionaries¶
Notes¶
There are three ways to loop through dictionaries: through the keys (the default), through the values (.values()), and through both at once (.items())
If you want one way to do it, just always loop through the items as you have access to both the key and the value at once
Combine dictionaries using update. Add items to dictionaries with brackets and assignment. Remove items from dictionaries with pop
Resources¶
Transcript¶
- hey everyone
- nick dear bertis here teaching you
- financial modeling today
- we're going to be talking about some
- additional
- python basics focusing on using
- python dictionaries this is part of our
- lecture series on
- exploring the parameter space and this
- is covered during this lecture series
- because we're going to need to use
- dictionaries to complete sensitivity
- analysis
- in python so
- we um like i just said we just need to
- cover a little bit of
- extra python basics before we can
- get into doing sensitivity analysis in
- python
- so let's look first at dictionaries
- and then the other topics we're going to
- look at in the
- follow-on videos within this extra basic
- segment
- are about list comprehensions and
- uh the python imports and
- installing packages but we're focusing
- in this video on
- dictionaries and we covered dictionaries
- before so
- if you forgot that or didn't see that
- video go back
- and look at the original video on
- dictionaries to get a quick introduction
- within the python basics segment
- but here we're going to dig more into
- using them
- so but we'll give just a quick recap on
- what a dictionary is
- and it's a basic python data type
- just like a list numbers floats integers
- uh strings all the basic data types
- booleans
- etc dictionary is one of the basics
- and like a list it holds other objects
- within it analysts
- you know is an ordered you just hold
- things in order
- for a dictionary it's key value pairs so
- it's
- you're storing your object
- under some key where you want to be able
- to look up the object by that
- key at a later time
- so here's an example of
- finding a dictionary looking up um
- values from the dictionary and looping
- through
- the dictionary so looping looping
- through the dictionary
- is totally new for us so
- here first i'm defining the dictionary
- and whenever you define a dictionary
- you're using
- the curly braces to do that that's the
- easy
- built-in way and
- you're going to have then the keys
- a key and then a colon and then the
- value and then a comma
- and then coming to the next key colon
- value
- comma and so on and
- so the example here is
- a dictionary of what level
- my coffee is at and how i'm feeling
- in relation to that so
- um when my coffee is at a high level
- i'm happy it's pretty high i'm still
- happy
- as it starts to drop to medium then
- feeling neutral
- if it's low then i'm getting sad i want
- more coffee
- if there's no coffee then i really gotta
- get some more and so i'm desperate
- and so in that dictionary you put its
- name
- and then you put brackets and you put a
- key
- here we're putting the pretty high key
- and so we're going to get the happy
- value as a result so that's how you can
- look up
- any item in the dictionary you look it
- up by its key
- so what's new for us is then looping
- through the dictionary
- and there are three different ways to
- loop through a dictionary
- which is part of why we didn't cover
- that yet because it's a little more
- complicated than looping through lists
- um the three ways you can loop through
- it are you can loop through the keys
- you can loop through the values or you
- can loop through both the keys and
- values at once
- and if you just want one way to do
- things you say why do we have three ways
- can we just always do one way to loop
- through dictionaries
- i would say just always do
- looping through both keys and values at
- once through calling
- dot items on the dictionary because that
- way you have access to both
- you don't necessarily have to use both
- um and that's why
- if you just want one way to do things
- then
- always do it with items it'll get you
- both the key and the value
- at the same time in the loop
- so the way that you do that with
- dot items so we have our familiar for
- loop here
- or something in something colon indi
- but here we're putting the dictionary's
- name but we're not just looping through
- the dictionary
- we're looping through dot items of
- the dictionary and that's what allows us
- to loop through both the key
- and the value at the same time
- and then over here we have not just a
- single value that we're looping through
- we're looping through two values at once
- the key
- and the value and so
- um you whatever you put first
- is in reference to the key and whatever
- you put after the comma
- you put it second that's in reference to
- the value
- so that's why uh here the copy levels
- are the keys and the emotions are the
- values and so that's why it's
- four copy level comma emotion because
- this is the key
- and this is the value and this is
- picking good names
- for each of those that correspond to
- what they actually are
- and then here i'm just putting out a
- sentence which explains
- how i'm feeling in relation to my coffee
- level so
- what i just said before when i got a lot
- of coffee i'm happy
- uh when it's out then i am not feeling
- great
- so that's the basic example and now we
- can
- look at how we can add and delete items
- from dictionaries after it has already
- been created
- so we have this coffee levels emotions
- dictionaries
- um and there's two way that we can add
- items one is we can take an entirely
- separate dictionary
- and bring all of it all of its items
- into this dictionary
- that's through the update method so you
- call dot update
- on the dictionary and you pass it
- another dictionary
- and that's going to take that second
- dictionaries items and bring them into
- the first
- so after the first now if the coffee is
- overflowing then i'm feeling burned
- and now that has come into the
- dictionary
- as well and then we can assign
- a single key value pair at once
- by uh basically doing what we would to
- look up a value
- by the key but then just putting equals
- and assigning the value
- so here i'm assigning the negative key
- to have the value of confused
- and so if there's a negative amount of
- coffee
- in my cup then i am confused because i
- don't know how that's
- possible so then
- we can remove items from the dictionary
- as well
- and we do that through the dot pop
- method
- so the dot pop you give it the key
- and then as a result it will give you
- the value you may or may not
- care what that value is sometimes you
- just call this
- and don't even assign it to anything
- just this would be your line of code
- if you really don't care about the value
- you just want to get this thing out of
- the dictionary
- but you can also save the value coming
- out of pop as well
- um so that's the quick overview on how
- to add and delete items from
- dictionaries
- let's go ahead and look at the jupyter
- notebook example
- so you see this actually happening in
- the code
- so here i'm just defining a dictionary
- again with curly braces
- um and with the key value pairs
- um key then colon then value
- and i like to write these on multiple
- lines
- uh but you can do it on a single line as
- well it's the same thing
- uh once you're inside those curly braces
- then you can have
- as many uh extra lines as you want
- you could do this if you felt like it
- it's only when you're outside of curly
- braces or parentheses or anything like
- that you can't just
- arbitrarily make lines
- and so i mentioned we have three
- different ways to
- loop through the dictionary through the
- keys through the values
- and through both at once and that's
- coming out of
- these keys values and items which gives
- you
- both at once so a and b are our keys
- one and two are our values and having
- those associated together
- is the items
- and so with dictionaries we can look up
- any value by
- its key so a and b are the keys one and
- two are the values
- and so we can look up one and two by a
- and b
- because that's the way we've set up the
- dictionary
- and then we can add a single item at
- once
- by basically doing the same
- way we would look up a key but then
- assigning afterwards and so here
- we've now added c the key c
- map to the value 10 into this dictionary
- and with the update method we can give
- it an entire second dictionary at once
- here we're going to add the d and e
- items into the dictionary
- and now we've got a b c d and e all
- in my dictionary
- and then you can also remove with pop
- and so here we're going to
- remove this a1 item out of the
- dictionary
- and the a value is going to be the one
- so that's what this print statement is
- showing you that
- we got the one out as a result of the
- pop
- and now that a associated one is
- no longer in the dictionary
- so um you don't necessarily
- need to do that assignment um here we're
- just gonna
- take b the b key associated to the two
- value
- out of the dictionary without assigning
- or anything
- and now we're left with just c d and e
- so looking at looping through dictionary
- what you would probably try to do in the
- first case is just to loop
- right through the dictionary without
- calling any method on it
- and what that does by default is it
- actually loops through just the keys
- so if you're trying to get at the values
- you're not going to get them directly
- that way
- um so this is basically implicitly doing
- the same thing
- as calling dot keys on the end of this
- but we saw we had not just dot keys we
- also had dot
- values and dot items and so when you
- go through values then
- it's going to go and print each one of
- the values and just to remind you what's
- in this dictionary
- 10 510 those are the three values
- in the dictionary
- and here without items then we can loop
- through both at once there you do need
- to
- put this comma whatever comes before the
- comma
- is going to be the variable that
- represents the key whatever comes after
- is the variable that represents the
- value
- and so we can use both of them at once
- in the loop so here we're saying both
- what the key is
- and what the value is in our sentence
- um and just to give you a little more
- context
- into what's going on in the background
- there
- if you look at what my dicks dot items
- is what we actually have in here
- is a list of tuples basically
- um and so what's actually coming
- if you loop here you're actually
- getting for items you're actually
- getting a tuple
- um as that value
- and a nice thing you can do in python is
- you can
- spread out a tuple if tuple has two
- items you can split it into two
- variables
- and that's exactly what we're doing here
- so we're taking this tuple
- of the key and the value and we're
- splitting it into separate variables
- by using this nice little shortcut um
- so that's just a little background to
- understand where the syntax
- comes from but you don't really need to
- worry about this
- just do this you can just copy this and
- work from this
- uh whenever you want to loop through a
- dictionary
- so that's the uh
- more more advanced than we touched on
- originally usage of
- dictionaries still basic but now kind of
- the full basics
- of dictionaries and we're going to come
- back next time to talk about
- list comprehensions in python so thanks
- for listening
- and see you next time
- you
Python List Comprehensions - Convenient List Building¶
Notes¶
List comprehensions are an example of “syntactic sugar,” or a feature of a programming language which is not necessary but makes things easier (makes the programming experience “sweeter”)
They allow us to write simple loops made to create lists with only a single line of code
Resources¶
Transcript¶
- hey everyone
- nick diabetes here teaching you
- financial modeling and today
- we're going to be talking about list
- comprehensions
- in python and this is part of our
- lecture series
- on exploring the parameter space and
- this section of the lecture series is
- covering some additional python basics
- that we need
- to be able to go implement sensitivity
- analysis
- in python so
- we um are picking up here
- in the lecture from how to do list
- comprehensions
- in python in the extra python basics
- section
- and so list comprehensions
- are not necessary at all
- they're something that we call syntactic
- sugar which means that it's something
- which makes things easier for you
- though it's not strictly necessary
- it's a feature of the language that
- makes writing the code
- sweeter
- even though it is completely possible
- to do it in a different way already it
- didn't actually extend the functionality
- of the language
- it just makes it easier to
- do certain things
- so what list comprehension basically
- does
- is it lets you do a for loop
- and create a list all in a single line
- so we've seen many times already in the
- course
- and it's a very very common pattern in
- programming to go through a loop
- and for each one of the loop you're
- going to
- [Music]
- do some kind of processing and create
- some kind of output
- and then put that output into the list
- and you're going to have one output into
- the list
- for each run of the loop
- um this comes up all the time
- and so you can see in the first block
- here
- how we know to do that right now and
- that's you first
- set up your output list before you start
- the loop
- then you have your loop and then within
- your loop
- you append to that list
- that you finally have all those results
- in a list so list comprehension
- lets you take these three lines
- and put it into one single line
- so here is the same exact loop with
- list comprehension and
- you can see that actually the loop
- statement itself
- four iron range five that comes over 100
- percent the same
- into the list comprehension and
- when you look at this the one other part
- that actually matters in here that's not
- just
- boilerplate of setting this all up is
- the actual computation part
- we're adding 10 to whatever the input
- value is
- and so that's the other part which comes
- over
- into the list comprehension so it's
- really minimized it down to
- just the things that we care about and
- not having to
- write all this other structure
- so it's whatever your output calculation
- is and then your loop statement
- and you just wrap that in brackets and
- that's a list comprehension
- and i think this is nice and readable as
- well this is just saying
- you know add 10 to each one of the
- inputs and the range up to five
- and make that into a list so i think it
- increases the readability on top of just
- making it easier and faster to write the
- code
- so a lot of advantages here with list
- comprehension
- if this feels overwhelming to you don't
- worry about it you can still write these
- loops just fine
- your code is going to function exactly
- the same
- it's just in my opinion a lot easier to
- write with
- list comprehensions than doing this
- full-on pattern
- now you don't want to abuse list
- comprehensions if you've got a
- complicated loop
- you probably don't want to make that
- into a list comprehension
- it's just going to become a really
- really complicated one-line statement
- but when you're doing simple things then
- a list comprehension
- makes a lot of sense
- so now let's go over and look at some
- examples of this and apply it in the
- jupiter notebook
- so still working on this additional
- python basics
- dictionaries list comprehensions
- notebook now in the list comprehensions
- section so first here i'm just
- showing the standard way that we've
- learned so far
- we've got an inputs list we want to add
- 5
- to each of those inputs that's our
- calculation the calculation
- could be absolutely anything that you
- want it could be running your entire
- model
- or whatever here we're just adding five
- and so we get
- five added to each of these inputs as
- the output
- and again that's setting up our empty
- list doing the loop statement
- doing the calculation appending that
- result and then we have all that
- and now it becomes one line uh just
- adding five
- to each of the inputs for each of the
- inputs
- and we're done so much easier
- in my opinion um
- and like i said uh
- this is a really trivial example here
- we're just adding five
- it was really simple but you can do
- anything you want
- with the logic
- and if you use functions you
- can really do a whole lot here because
- you can put all your complex logic
- into a function and then
- what the loop itself becomes simple and
- so you can condense the loop
- into a list comprehension
- without the function this would be a lot
- of logic to try and cram
- into a list comprehension but with the
- function
- it becomes very simple so all this
- function
- is doing is uh taking a numeric value
- if it's less than two it returns low uh
- if it's between two and three it returns
- mid
- and otherwise it returns high
- so with the original way that we've
- learned
- the list building pattern um
- it basically looks the same as
- the last loop um but instead of adding
- five now we're calling
- the function here and we're passing in
- the input and getting the output as a
- result of that and appending that in the
- list
- so for our inputs um
- which were one two three one is low two
- is mid and 3 is high
- and with list comprehension we can still
- make this into a single
- line so
- you can really do very powerful things
- if you take
- your complicated logic and you wrap it
- in a function
- then doing a loop with that function
- across a bunch of different inputs
- collecting all those
- results into a list becomes a single
- line now so much easier than before
- um and so that's the basics of list
- comprehensions and the majority of the
- time
- that's all you'll ever need there are
- more advanced ways to use them as well
- let's just kind of
- quickly go over those
- so we can do conditionals
- in the list comprehensions as well
- and that's conditional around whether to
- append whether to add the output to the
- final list
- so here again we're looking at one two
- three
- and if the inputs less than three then
- we're going to add it to the list
- and so we get one and two out of that
- and then looking at the list
- comprehension so
- you know here's the basic uh list
- comprehension which gets us
- just the original inputs back and then
- we add
- our condition onto that and
- it's going to give us only the
- inputs which satisfy the condition in
- the final
- resulting list
- and you can do those same calculations
- on the inputs as well
- so here it it kept the one and the two
- but now it's adding five to it as well
- um so that's conditional for whether to
- include the value in the resulting list
- you can also do a conditional
- on the value itself so
- here is our long form loop where
- if the input's less than three we're
- gonna append it and otherwise it's too
- high
- we're gonna append too high to the list
- um and so here we run that
- and we're going to get uh one two and
- two high because three
- is not less than three and we can do all
- this in one line with a list
- comprehension
- so when you're doing a conditional on
- the
- value then that conditional comes
- onto the left side of the list
- comprehension whereas here
- or conditional on whether to keep the
- value was on the right side
- of the list comprehension
- and so here we're going to do um
- we're going to do the input if the input
- is less than 3
- otherwise we're going to get too high so
- this is an inline
- if else statement
- if it's less than three otherwise too
- high
- and we're doing that for each of the
- inputs and so that's
- how we get the same result as this
- longer form loop
- um and you can combine all three of
- those elements if you'd like
- so by the time you're doing that it's
- starting to get a little bit hard to
- read honestly so
- um it may at this point be better just
- to go back to a long form loop now that
- you've got multiple things going on
- but you can combine all these elements
- if you want to
- um and then just a quick mention for
- there are comprehensions for other data
- types and pythons
- uh we haven't even talked about sets and
- generators as data types
- we're not really gonna go there in this
- course they're not really necessary for
- what we're doing
- but for those and as well as
- dictionaries you can do dictionary
- comprehensions as well
- but that's a little bit more advanced
- you can check out
- uh this resource for more information on
- that if you're
- interested
- and then that wraps up the material on
- list comprehension
- and there are lab exercises on this
- as well and i forgot to mention at the
- end of the dictionaries video
- that there are also lab exercises for
- that
- and the same notebook so just go through
- that whole
- um jupiter notebook the dicks and list
- comprehension
- lab and just complete all the exercises
- in both the dictionaries and list
- comprehensions sections
- for the lab exercise so we're going to
- come back in the next video
- to talk about the python import system
- and how to
- install packages so thanks for listening
- and see you next time
Python Imports and Installing Packages¶
Notes¶
Import can be used for third-party and built-in packages, but also for your own code offloaded into separate files
I had you install Anaconda to get Python because it includes most of the Python packages we would want to use pre-installed. So we haven’t had to install any package up to now
With more than 250k packages out there and only about 200 installed in Anaconda, the time will come when you need to install something
It will even happen in this course because we will use some packages I have created
Transcript¶
- hey everyone
- nick dear burst here teaching you
- financial modeling today we're going to
- be talking about
- imports in python and installing python
- packages this is part of our lecture
- segment on exploring the parameter space
- with sensitivity analysis and the sub
- segment
- on additional python basics that we need
- to be able to
- attack sensitivity analysis in python
- so we're here in this extra python basic
- section
- of the sensitivity analysis lecture
- starting here with understanding imports
- in python
- so we've already used the import
- statement a little bit we've imported
- numpy we've
- imported pandas um
- and what that import is doing
- it is loading this external package
- which we can then use and
- that makes it sound and seem like these
- third-party packages
- numpy pandas and all the others that we
- can potentially use
- makes them sound like there's some kind
- of uh
- you know very structured special things
- um that you need to set it up in some
- really special way
- um but it's quite a bit simpler than
- that really it's
- they're just sets of python code and
- just a bunch of files
- and when you import it it's just loading
- the python code in those files
- into your notebook or wherever you're
- working
- and so just like the authors of numpy
- and pandas have written
- all these python files with functions
- and classes that you can use
- you can also write your own code and put
- them in python files
- and import your code from python files
- in the same exact way so the way that
- that works
- is you say import something
- what happens is python searches
- on your computer in certain spots to see
- if it can find
- uh something dot p y dot p
- y is a python file the plain text file
- with a dot py extension
- and so it's first it has a certain order
- that it goes and searches
- your computer in and the first place
- it's going to look
- is in your current folder
- so if you have right next to your
- jupiter notebook you have a something.py
- defined there and it has some functions
- there are classes in there
- when you import something it's going to
- bring in the code
- from that something.py
- file and then if
- it can't find any something there then
- it's going to go on
- and continue looking through the
- different locations that it has set up
- to search
- and beyond your current directory the
- main other locations are going to be
- a certain spot where it installs all
- your packages
- um and there's often a couple different
- spots that it can put the packages so
- those will be multiple different spots
- that it looks in
- and order so when you install a package
- it'll put it in this special spot
- so when you import then if you don't
- have a file defined with that name it'll
- go look
- where your packages are and then be able
- to import it from
- there so that is something to be
- mindful of because it does always look
- in the current directory first
- if you actually created a numpy.py
- file in the current directory then when
- you import numpy
- you're no longer getting the numpy
- package you're getting your
- numpy.py file and so that is something
- to be
- careful about that you don't want to
- define
- python files with the same names as
- packages that you might be meaning to
- import it could definitely cause a
- conflict
- so you can write your own custom code
- and you can then import it
- into your notebook later on so
- if you have any functions or classes
- that you create as
- as you're building out your models and
- you say hey that's actually a pretty
- generally useful thing that i just built
- i'm probably going to want to use that
- in my next model not just this model
- then you can take that function or take
- that class and you can offload it
- into the separate python file and then
- no matter how many notebooks you have
- you can just keep importing that same
- function or class in your notebook and
- then
- say that you wanted to add a new feature
- to that function
- it now gets a new default a new argument
- um and it can do additional things now
- um you make that change in one spot in
- your python file and that will carry
- through to all your notebooks that are
- using it
- so it goes even further in this code
- reuse direction
- to keep from having to repeat yourself
- so what happens
- when you import a file is it executes
- everything in that file so
- you can think of you know like executing
- a code cell
- in jupyter you can think of your python
- file as being the contents of one code
- cell
- and importing that file is the same as
- running
- that code cell so generally
- all that you want to have in there for
- the most part is going to be function
- and class
- definitions you don't want to generally
- be doing anything
- uh you just want the setup the
- definitions so that you
- can do something with those functions
- and classes
- um because uh
- weird things can happen if you you know
- are importing something multiple times
- and you're expecting it to do something
- python only imports it once and then
- it caches it so it doesn't have to keep
- importing it so
- you can run into unexpected behavior if
- you're trying to run logic
- when you import instead just have
- functions and classes
- for the most part and then
- then when you import it you'll have all
- those defines so that you can use them
- in your notebook
- and you know it's a little bit more
- advanced to go to the structure than
- just having everything all in one
- jupiter notebook of course
- but it is a more maintainable structure
- as you go to build larger and more
- complex models and as you go to build
- uh more and more different models where
- you might want to share
- code across your different models
- so it's a good thing to learn about
- you might not have to go there in this
- class
- [Music]
- as we get further in the course the
- fourth project in the course is the dcf
- model and the third project
- is a wac model which the whack is part
- of the dcf model and so i have seen
- students
- take their functions from the wac model
- and refactor them out
- into these separate python files and
- then use them
- in their dcf model so they don't have to
- like rewrite all the whack parts of the
- model so that's
- definitely a good application for this
- within this class
- but i'm mainly mentioning it here just
- so one that you understand
- what imports are and that they're not
- anything really special it's just
- running the contents of some file which
- has python code in it
- um and that's so also you can know about
- this as
- a way to grow into as you start to go
- and continue to apply this stuff
- out of the course and maybe you find
- your jupiter notebooks to be getting
- really long and unwieldy
- or maybe it's even just that you have a
- lot of code in your jupiter notebook and
- you really want it more focused on just
- the results
- and not showing so much code to the
- reader of the model
- for all these different use cases going
- to offloading your code
- into separate python files is a good
- solution
- so um as we mentioned
- these these packages that you can
- install all they are are just plain
- python files and defined functions and
- classes
- just like we've already learned how to
- do
- and going along with this course i had
- you install anaconda
- for your python distribution and that's
- because
- it comes with around 200 packages
- already pre-installed
- and it's most of the common ones that we
- would want to use so most of the time
- you don't need to install the package
- you already have it installed from
- anaconda
- but there's around 200 in anaconda and
- there's around
- 000 packages out there that you could
- potentially use
- huge number of packages and this is one
- of those things that makes python so
- great
- there's a package out there for
- everything that you could want to do
- essentially um it'll make your life so
- much easier just finding the correct
- package to work with instead of having
- to
- recreate everything yourself so
- you find this package you googled about
- it you landed on some github page or
- pipi page or something
- explaining what this package is now you
- say i want to use this
- what's the next step so um
- the way to do this is with pip pip
- is the python package installer um
- and it's very simple it's just pip
- install and then the name of the package
- and that
- installs the package for you now where
- do you run this
- that happens in the terminal so that
- anaconda prompt
- would be a good place to run that uh but
- jupiter does
- actually have a shortcut where you can
- run terminal commands
- instead of just python code and you do
- that by just putting an exclamation mark
- before whatever you're running in the
- cell and that says
- hey jupiter i'm trying to run something
- in a terminal not
- in as python code um
- and so that would be exclamation park
- pip install
- and then the name of the package to
- install it from
- jupiter and you only need to install a
- package once
- once you install it you have it on your
- computer for as long as you have python
- installed
- the only time that you might want to run
- this again is
- to upgrade the package you can add an
- upgrade flag into that
- we'll talk about that a little bit later
- in the course when we need to use that
- but generally install it once you have
- it and you can just use it you just have
- to import it in each session
- but then you can keep using it just like
- we have been using numpy or pandas or
- anything you have
- already installed
- um so let's look at a quick
- example of that so let's jump over to
- the jupiter
- notebook and this is the same one with
- all the other additional basics
- dictionaries list comprehensions
- here we're um imports and installing
- packages
- and so um the reason that we're getting
- to installing packages now
- in the course is because
- uh we're going to go and do sensitivity
- analysis
- with a purpose-built package which is
- made for that purpose
- and the reason this is not an anaconda
- is because
- i actually wrote this package um
- and it doesn't hasn't gotten popular
- enough yet to make its way into anaconda
- it's got a long way to go
- until it gets there maybe someday uh but
- until then
- we're going to have to just install it
- manually
- uh to be able to use it so
- that's uh what we have here
- is pip install sensitivity is the name
- of the package
- i was amazed that this name was
- available for me to take
- uh it was the perfect name for the
- package
- um and all you do
- is just exclamation mark pip install and
- then the name of the package
- so let's go ahead and try to run that
- and when you do these exclamation mark
- commands
- uh it does it looks like it's doing
- nothing for a long time and then it
- spits out the result
- all at once when it's done you don't see
- it like stream
- the result as you go if you're running
- in the terminal you would see all this
- stuff happen line by line and jupiter
- just spits it all out at the end
- um and so you're going to see probably a
- lot of requirement already satisfied
- that's fine just ignore that just scroll
- all the way down to the end
- and here it looks like i even uh
- i actually already had the package
- installed and so the first one
- up here was requirement already
- satisfied sensitivity
- um but if you uh
- pick some other package that you don't
- have
- and you should see this for sensitivity
- when you go to install it
- you're going to see at the end
- successfully installed
- and then the name of the package and
- then the version of the package
- and then you can start using that
- package as soon as you want
- um so with sensitivity i can go ahead
- and import sensitivity
- and then i would be able to use the
- package
- so make sure to run that with
- sensitivity
- not this other package and then go ahead
- and try the import
- you should see it just execute and the
- number change here
- and nothing else happen and that means
- that you have
- installed it correctly
- so that's a quick overview on
- imports in python and installing
- packages we're going to come back
- next time to start implementing
- sensitivity analysis
- in python using the sensitivity
- package so thanks for listening and see
- you next time
Introduction to Sensitivity Analysis in Python¶
Notes¶
With sensitivity analysis in Python, we can get DataFrames looking similar to the tables with conditional formatting we saw in Excel
We can also output hexbin plots which show the same graphically
Unlike Excel, we are not limited to analyzing two inputs at once, though it still makes sense to visualize the output in pairs of inputs
The basic setup with pure Python is fairly simple: use loops over the possible input values and call your model function in the loop, saving the output associated with the inputs. Changing multiple inputs at once means multiple nested loops.
Then you have to add the conditional formatting or hexbin plot
The sensitivity package reduces this all to a couple lines of code, regardless of how many inputs you want to look at
Resources¶
Transcript¶
- hey everyone
- nick dear bertis here teaching you
- financial modeling and today
- i'm going to be talking about
- sensitivity analysis
- in python this is part of our lecture on
- exploring the parameter space
- so we left off last time we had gone
- through some
- additional python basics that we were
- going to need to be able to carry out
- sensitivity analysis in python i was on
- list comprehensions dictionaries
- installing packages
- and now we're going to go ahead and
- actually implement sensitivity analysis
- so for sensitivity analysis in python
- we're looking at
- two main kinds of ways that we can
- visualize the output
- so the new one which is different from
- what we're able to do in excel
- is this hex bin plot that you see here
- and this is analogous to the conditional
- formatting
- on a table in excel only in graphical
- form
- so here uh it makes the regions
- of this two-dimensional area
- corresponding to the value of the
- outcome
- so you have your two different inputs on
- the two different axes
- and then your outcome is the color
- um and so here high years to retirement
- is red
- low years to retirement is green and
- getting darker green
- the more that it decreases so we can see
- clearly from this graph that
- as savings rate increases and as the
- person gets promoted more often
- then they're going to be able to retire
- sooner
- the other main output that we have is
- exactly what we have in excel which is a
- table with conditional formatting
- applied to it
- so this is showing the same information
- as the hexton plot only with each of the
- numbers
- in there as well uh so it's mostly a
- personal preference
- uh with which one you want to go with
- but these are the two main ways to
- look at the two inputs at once with
- sensitivity analysis and
- visualize that of course with one way
- then you can just plot that
- with a typical line plot
- so the process to carry out sensitivity
- analysis and python
- if you don't want to use any packages
- you just want to use pure python
- then it's basically you do a loop
- over each input that you want to
- examine so you might say i want to look
- at
- uh 30 40 50 savings rates
- and so it'd be like four save rate in
- 30 40 50 in a list um
- and then you run the model with uh each
- of those inputs
- passed in collect the results keep them
- associated
- with which inputs are related to those
- outputs
- and then put it all together to
- visualize
- um so then if you have more than one
- input
- you just go ahead and do additional
- loops and nest those loops
- within each other so for save rate and
- savings rates for
- uh number of promotions in
- uh you know two three four five
- something like that nested under each
- other
- and then nested under all the loops is
- where you actually run your model
- with each of those inputs again collect
- the outputs associate them with the
- inputs and then
- visualize it
- um then you know you start to look up
- more
- than two or three inputs at once and all
- of a sudden you're nested nested nested
- more and more and all these loops
- um and that can be pretty messy um
- so there is a way to resolve that there
- is a
- python has a built-in package called
- intertools
- tools for iteration which goes a little
- bit beyond
- just what the base language does
- and one of those basically allows you to
- do
- like a nested for loop but with only a
- single line of code so that's what this
- editor tools product is
- um and so you can use that to then
- collapse however many loops you would
- have onto one line um
- but then it's a little more difficult to
- understand what's going on there
- so i would if you're sticking with
- this approach for sensitivity analysis
- and we'll talk in a minute
- about a package we can use that makes
- all this much easier
- but with the pure python approach i
- would say two or three inputs at once
- just write out in the individual loops
- as you get more than that
- then you should consider using
- intertools.product
- as a replacement for the nested loops
- so here's an example of what that
- looks like the code that can make
- sensitivity analysis happen
- with just base python so
- here we're saying that we have a
- function called model and that's
- the function which runs our entire model
- so it takes the inputs
- and then it spits out the result of
- running the model
- so that can be you know calculating the
- years to retirement from the savings
- rate investment rate etc
- or any other model that you could
- possibly imagine
- as long as you can you can always
- represent the model as a function
- uh converting inputs to outputs and so
- if you do that
- then you can fit it into this structure
- just fine
- so we have two different inputs we're
- trying to examine here input one input
- two
- and for each of those we have two
- different values of
- the inputs that we wanna look at so for
- input one we wanna look at one and two
- input two we wanna look at four and five
- we set up a list to store all the
- results and then here we have the nested
- loop
- so we're going through each of these
- input lists getting an input
- out of each one and then within all the
- loops
- calling the model with each of the
- inputs then we get the result
- from the model and we associate the
- uh inputs with the output in the result
- here by creating a list of tuples
- where each tuple has everything grouped
- together
- then we create a data frame from that
- list of tuples
- and we can see the results of the
- sensitivity analysis here
- in the data frame of course this is not
- doing any visualization yet
- that part is going to be added on after
- this
- um so this
- was kind of the process which is out
- there
- this is what people are doing right now
- in general
- um and i thought that there should be a
- good package
- which makes this process easier
- especially
- you know not only doing this but then
- taking the result and visualizing it as
- well
- but i really couldn't find any tool out
- there which
- was built for this purpose
- i think a lot of that reason is because
- certainly a lot of financial
- institutions
- are already using python and they're
- building models out in python
- but for the most part these institutions
- are not going to be open sourcing their
- code they're just going to be keeping it
- within the company as their own
- intellectual property
- uh they want to have the rights to it
- and not anyone else
- and so i think there have been a lot of
- these tools created
- but they're just not out there for
- anyone to use they're within these
- banks and financial institutions that
- keep a close
- guard on the tools that they've
- developed
- so it really takes uh you know someone
- who both has the knowledge and uh
- is willing to be able to contribute
- to create an open source package without
- a lot
- of immediate benefit from it so
- a professor teaching a financial
- modeling course
- is kind of the ideal person to do that
- so and you know unlike in excel
- you can write add-ons for excel but
- that's kind of heavy weight
- um and in general people just use excel
- as is
- in python you have the base language but
- then you have all these additional 250
- 000
- packages open source packages which have
- been created to extend the functionality
- of python
- and it's really easy for anyone to
- create a package
- and contribute to the ecosystem create a
- tool that solves a problem
- so that nobody else has to continue
- solving the same problem in their own
- work
- so i went ahead and created the
- sensitivity package
- in python which simplifies this whole
- flow as well as the visualization
- of the results and makes this whole
- thing
- very easy so i took the time
- to kind of solve this once in a general
- way and now everyone in the world
- can benefit from my efforts
- so that is really uh the big power of
- python that anyone in the world can
- contribute and it can make everyone else
- and the world
- more productive so everyone's not
- reinventing the wheel all the time
- so let's look at an example with
- the sensitivity package
- so from sensitivity we're going to
- import sensitivity analyzer that's the
- main class which
- handles all this and then you create a
- dictionary
- where the keys of the dictionaries are
- the names of your
- inputs the arguments to the function
- your model function
- and the values are what
- each individual values of the inputs you
- want to look at
- so one and two for input one 4 and 5 for
- input 2.
- then you pass to sensitivity analyzer
- that dictionary of the inputs
- and your model function and that creates
- an instance of the sensitivity analyzer
- and then the df data frame
- attribute of the sensitivity analyzer
- already has the results
- of doing this nested loop
- and collecting all the results and
- everything that have been done here
- and we'll see in a minute here in the
- example that is also
- similarly easy to visualize all the
- results as well
- so let's go ahead and look at the
- jupiter example
- for all of this
- so the first thing that we're going to
- do is
- install the sensitivity package
- and so in this is something that you
- would run in a terminal but jupiter has
- this shortcut
- uh as mentioned in the video on
- installing packages
- that uh you put the exclamation mark
- that means run it
- in a terminal in the background and then
- we want to do pip install
- sensitivity and i'm going to go ahead
- and add in
- upgrade because i already have it
- installed and i know that i've released
- some updates for the package and i want
- to have all those updates here
- so i'm going to run that and it's going
- to look like it's doing nothing for a
- little bit and then eventually
- it will pop out all the output from the
- result
- as we see now and we can see
- that it successfully installed
- sensitivity
- as of making this video 0.2.5 is the
- current
- version um you may just get
- requirement already satisfied for
- everything if you already have the
- newest version
- um and then if you run that first you
- don't really have to do this step but
- i'm just going to go ahead and
- restart the kernel for good measure
- so now let's uh go through
- what the process looks like kind of the
- original way without the sensitivity
- package
- and then we'll go into how to use the
- sensitivity package
- um so i'm going to import pandas
- that we'll use for collecting the
- results and i'm defining the model
- function so again this can be absolutely
- anything
- it can be your full financial model
- here we're just taking one number to the
- power of another number
- it really doesn't matter what happens
- inside of here that's the beauty of
- using
- functions we can plug whatever
- functionality
- we want into this structure and it works
- exactly the same
- so when i run the model i can get a
- result from it
- so then if we want to look at three
- different values for x1 three different
- values for x2
- then when we look at the nested loop we
- can see
- that we get basically each combination
- each pairwise combination of the inputs
- so we get nine total cases from three
- cases for each
- then we can add in calculating the model
- running the model
- um so that's just calling the model
- function
- on the inputs from the loops
- and then uh getting the result and here
- we're just going to print out the result
- as the next step
- um and then after that let's collect the
- results
- so taking the same loop but now adding
- to it that
- instead of just printing the result i'm
- going to have an output list
- and i'm going to append to that a tuple
- which contains
- each of the inputs as well as the output
- and then we can see that we have each
- pair of inputs
- associated with the output
- then we can put that into a data frame
- so if we give a data frame a list of
- tuples and then the names of the columns
- it's able to create a data frame from
- that
- and then we can add some styling
- about the result so here i'm adding a
- red yellow green color map
- um to the y column the output column
- uh which is now showing the high results
- in green
- and the low results in red
- then the other way to go about it is to
- use a hexman plot
- um so that's also
- off of df.plot just like we had done for
- all the other plots with pandas
- and you give it x and y as your two
- input variables and then
- c that stands for color
- is going to be determined by the outcome
- variable
- and then this grid size says
- going in each direction how many um
- like blocks should there be this is like
- three by three
- blocks in the graph
- again we pass that color map
- red yellow green um
- and then this share x equals false
- makes all the formatting work correctly
- um so that's without the library
- and then with these color maps you can
- do underscore r
- to reverse the color map
- if it turns out that a low number of the
- result is a better thing
- like years to retirement we want to
- retire quicker so there you would want
- the reverse
- red yellow green color map
- but all this is a little bit involved
- it's not super complicated but
- there's a fair number of steps here so
- the sensitivity
- uh package is going to make this all
- easier
- so with the sensitivity package we set
- up that
- dictionary of the inputs and then we
- create
- the sensitivity analyzer
- and we pass to the sensitivity analyzer
- that dictionary as well as the model
- function
- and notice that there's no open close
- parenthesis here
- that's because we're passing the model
- function
- itself and not the result
- of calling the model function as soon as
- you put the parenthesis it's going to
- call it evaluate it return the result
- we want to pass the function itself so
- that sensitivity analyzer can use this
- function
- that we're passing to it
- um so you run sensitivity analyzer and
- you'll see
- this progress far go by here the model
- didn't take any time so it basically
- filled up immediately
- um 450 iterations per second
- um and you'll see a random nine
- iterations in total because we have
- three times three
- uh cases of inputs
- um so you know there's definitely a
- chance that you can
- put too many inputs here and you get a
- really huge number of cases
- and then you'll see this thing just
- taking forever and then you should
- reevaluate how many inputs you want to
- look at
- so then we've run sensitivity analyzer
- now we can get that same exact
- data frame which we had seen before but
- just it's already there
- ready for us we didn't have to go and
- calculate it
- and then for the plots
- we just do sa.plot and then we have that
- hexman plot
- easy as that and we can also get these
- styled data frames
- by doing sa.style dfs
- and that is going to give you the data
- frame
- with um conditional formatting applied
- to it
- and there are options that you can apply
- to
- the sensitivity analyzer as well to
- customize the output
- and so i'm going to do a few different
- things here
- so i'm going to give it some labels so
- that it'll change out x1 x2 for
- whatever names i want to call the inputs
- i'm going to pass grid size of three so
- that it makes larger
- blocks here reverse colors that was like
- adding underscore r
- to the color wrap before it just flips
- the color map
- then you can also pass a custom color
- map
- and if you want to know what are all the
- color maps you can use just google map
- plot lib color maps
- um that will take you to choosing color
- maps in matplotlib
- and you'll see all these different ones
- that you can pick
- so all these names on the left are
- things that you can pass
- to color map to get a different color
- map
- um and then uh
- yep that's all the options so then i'm
- going to run this and then plot and now
- we can see
- it has a large grid size it has the new
- color map it's reversed the color map
- and we see the labels coming in instead
- of the
- actual names of the arguments
- and we see that on the
- data frames as well
- um and
- the really beautiful thing about this
- library is you can keep adding more
- inputs
- that you're looking at and you really
- don't have to change your code
- at all it works in the exact same
- structure
- so here we have a second model it's got
- three inputs this time
- and now we've got our dictionary which
- has the three different
- inputs um and three different values of
- each
- so we run that this time we can see it
- ran 27 different
- cases three times three times three um
- and what we see when we plot it is that
- now we get
- three different plots all at once
- without having to do any extra effort
- we get x1 versus x2 we get x1 versus
- x3 and we get x2 versus x3 so we get all
- the different combinations of the
- different inputs
- and the relationships between them
- so really easy to run a lot of different
- inputs and visualize it all at once with
- just a couple lines of code
- and then we'll see the same thing with
- the style data frames
- um we'll get one verse two one verse
- three two verse three and as you
- continue to add more
- inputs you'll get all those combinations
- so it can become
- a lot of output really quickly
- um and if you need to look up
- any so this style data frames you can
- see i saved it into styled
- predict it does automatically print out
- the results
- even if you save it into a variable
- you'll see what we have here is actually
- a dictionary
- where the keys are tuples
- and the values are the style data frames
- so you can also look up
- reference any of the individual results
- that you want to
- look at
- so we can also do some additional
- styling
- we can change the number formatting of
- the results as well
- and you can pass this in either when you
- create the sensitivity
- analyzer at the beginning or to the
- style dfs
- command you can pass the number format
- and this number format works exactly the
- same as the
- pandas number formatting uh that we
- learned from the styling
- penis data frames lecture
- um where you basically put the same kind
- of string
- as like an f uh only you don't put the
- variable here
- you just put nothing there and then a
- colon and then the format
- code so you can see this is doing
- dollars and then
- uh formatted with commas and zero
- decimal places
- and we see that all coming here as well
- so that covers the introduction to
- sensitivity analysis
- in python we'll come back next time to
- add the sensitivity analysis into our
- existing dynamic salary retirement
- model so thanks for listening and see
- you next time
Sensitivity Analysis in Python Example¶
Notes¶
Here we will focus only on using the sensitivity package rather than carrying everything out manually
We need to go back and add an optional argument to the model about whether it should print the results, otherwise we will have the results printed a huge number of times as we run the sensitivity analysis
The sensitivity package is made to work with functions where each input is passed separately, whereas our model function takes a single dataclass instance. To make our model function work with the sensitivity package, we need to create a wrapper function which takes the separate arguments, creates the dataclass from them, passes that into the model function and returns the result. You can copy my snippet to do this with your model.
List comprehensions are a nice easy way to specify values in a range, but you can also hard-code these lists
Be careful not to look at too many input values as execution could be very slow. The progress bar will tell you how many cases of the model you are running and show how long it is taking.
There are a number of options to customize the output from the library. You can change the names of the inputs and results, the color map, change direction of the colors, the grid size on the hexbin plots, and the number formatting in styled DataFrames.
Transcript¶
- hey everyone
- nick diabetis here teaching you
- financial modeling today
- we're going to be looking at an example
- of adding sensitivity analysis
- to an existing model this is part of our
- segment
- on exploring the parameter space
- so we left off last time having done
- an introduction on sensitivity analysis
- in python and looked at some of the
- different outputs we were going to
- produce and approaches
- we could use and now we're coming to
- actually apply that to our existing
- dynamic salary retirement
- model so let's go ahead and jump over to
- that model
- so we can build this extension to the
- model out
- and you can find the um completed
- extension from this exercise on the
- course site
- and i would recommend that you take a
- look at that
- completed example as you go to
- work the lab exercise for this and to
- add sensitivity analysis to your own
- models in the future so
- um we're gonna add sensitivity analysis
- so we can go ahead
- and make that as an additional section
- down here
- sensitivity analysis
- um and you would want to put a
- description of
- what you're going to be analyzing why
- what are the takeaways
- um but i'm going to leave that out for
- now for a second time
- um and
- i know that i'm going to need to use the
- sensitivity analyzer so i'm going to go
- ahead
- and add that import up here
- from sensitivity import
- sensitivity analyzer um
- sometimes yep if you tab complete
- sometimes they will tap complete it for
- you so that
- worked out for me then i'm going to
- restart kernel
- and run all cells so that we have
- everything from the model
- defined and then can just work with it
- below for the sensitivity
- analysis
- um now
- we're ready to start building out the
- sensitivity analysis
- but one thing that you may notice about
- my existing model function used to
- retirement
- is when i call it it prints out
- output and when we go to do sensitivity
- analysis
- basically this function is going to get
- right a bunch of times
- with different inputs and
- um we're going to see that
- doing that without any changes we would
- get this whole print output
- for as many times as we're running the
- model and we could be running the model
- thousands of times
- so we don't want to get thousands of
- copies of this
- print output for the different output
- cases
- we're already going to be storing the
- main output that we want to look at
- separately so before we can even add the
- sensitivity analysis
- i'm going to go back and make a
- modification to the existing model
- to make it optional whether it prints
- out
- the results um
- so we've already talked about um
- optional arguments before
- we can add an optional argument here uh
- print output equals false so it defaults
- to it should not print any output
- and now i'm just going to go to each of
- the print statements and say if print
- output
- then it's going to print otherwise it's
- not going to print
- so i'm just going to do the same thing
- uh with each of these
- and i'm going to rerun that to redefine
- that function
- and now you'll see that when i run this
- i don't get
- any output there i just have the final
- answer
- storm and the variable well with this
- usage we do actually want to
- print the output so i'm going to put
- print output equals true
- and now we're back to exactly what we
- had before for the original model
- but we're also able to call the model
- without producing all that print output
- which is what we're going to need
- to go into sensitivity analysis
- so now the model is ready for us to go
- and add sensitivity analysis
- so now we want to use the sensitivity
- analyzer
- but there's one other thing we have to
- do
- to prepare the model function
- before we can pass it to the sensitivity
- analyzer
- the sensitivity analyzer is expecting to
- be able to pass
- each argument separately to the function
- but the way that we structure our models
- is we use a data class
- we pass only a single data class into
- the function
- and not each of the separate arguments
- so we have to create a function
- that will take the separate arguments
- construct the data class from those
- arguments
- and then pass the data class into the
- function
- and return the result of that function
- so that it's basically a wrapper
- around the model function which allows
- it to take the input separately
- rather than as a data class so
- we can write that function so i'm going
- to call that year's retirement
- separate args
- and i'll come back to the arguments
- section in a moment
- um and then what we're going to do is
- we're going to
- create an instance of model inputs i'll
- also
- come back to this in a moment and then
- we're going to return
- calling the original years retirement
- function
- on that data
- now what we're going to do for the
- arguments themselves
- there's actually a shortcut in python
- which just says
- let me take any number of keyword
- arguments
- keyword being where you say like
- starting salary equals
- ten thousand or uh promo raise equals
- five percent so we can take any number
- of those
- and then it will just take all those and
- be able to pass them into the model
- inputs
- so that um shortcut
- here is a star star
- on a variable name and the convention is
- to do star star
- quarks so that just says any number of
- keyword arguments
- it's going to take those and it's going
- to put them into a dictionary
- coming into the function you have a
- quarks dictionary
- um so let me just print that to make
- that clear
- and then doing it again here it spreads
- it back out into
- the keyword arguments so this will take
- keyword arguments and collect them into
- a dictionary
- and then this will take that dictionary
- and spread it back out into the keyword
- arguments
- um so not expecting everyone to fully
- understand what's going on there
- you don't have to understand it you can
- just copy my code snippet and
- change out the model function
- and the name of the function and you'll
- be good to go to use the sensitivity
- analyzer
- so to show what this is doing i'm going
- to call this and i'm going to say
- starting salary equals 10 000
- and you'll see from the print output
- that it
- prints out the
- starting salary in a dictionary
- with this as the value and
- you can add other arguments here 30
- promotion raise
- we can see that also comes into the
- dictionary
- and then we ultimately get the result
- from that
- so
- this is our wrapper for the function
- which then is able to
- call the model and return the result
- so now that we have that working
- then we can go on to
- the next step which is to actually uh
- use the sensitivity analyzer
- um that's something weird is going on
- here because no matter what
- inputs i'm putting i'm still getting uh
- 28 years to
- retirement um
- oh yeah i see the mistake here uh here
- and a lot of people may make these
- mistakes in their own models
- um here data was being passed to the
- function but here i used
- model data so it wasn't actually able to
- pick up the data which is being passed
- to the function it was just using the
- overall model data each time
- and so i'm going to make sure that that
- matches up with the function argument
- and now i'm going to restart and run
- this thing
- all again and now we should see a number
- other than 28 come up here hopefully
- yeah there we go now it's actually
- working if you make a million dollars
- off the bat then you'll be able to
- retire in only five years
- okay and then back without passing any
- arguments we're back to 28 so it looks
- like this is all working properly now
- um so next we want to create that
- dictionary
- of the inputs that we want to change
- around
- so i'm going to start it out simple and
- we'll expand on this
- so sensitivity values um so let me just
- look at starting salary
- let me look at you know as low as 40
- 000 or as high as
- a hundred and twenty thousand and then
- let's look at the interest rate
- um and let's look at
- a three percent rate and a ten percent
- rate
- so then we have everything that we need
- to go ahead and run the sensitivity
- analyzer
- so then i'm going to create an instance
- of the sensitivity analyzer
- i'm going to pass it the sensitivity
- values
- and i'm going to pass it the model
- function
- the one that takes the separate
- arguments
- so then we see that it ran four
- different input cases here
- two times two and
- now we can look at the results so we can
- look at the full result
- data frame there each of the pairwise
- combinations
- and the user retirement
- um and we can
- create the resulting
- hexman plot
- and then we can um
- create the style data frames
- here just a single data frame for now
- um so that's pretty much what you would
- want to be seeing from sensitivity
- analysis as well as
- you know some description of the results
- that you found
- at the end um but there's a fair amount
- we can do here
- to clean things up and to make them more
- comprehensive
- so first thing is we can pass some
- additional options to sensitivity
- analyzer to clean up the output
- so some of those additional options
- would be
- that we want to
- label the results so we can do result
- name equals years to retirement because
- we can see right now it's just coming as
- result
- uh result
- result but we put years to retirement
- here as a result name and then we get
- uh years retirement years for retirement
- here's to retirement
- um and then we'll notice that
- right now it's highlighting the high
- years to retirement as bringing in the
- low
- as red that's the opposite of what we
- want
- so we want to reverse uh
- the colors reverse colors equals true
- um and then with that we will see
- um that now it's showing red for the
- high year's retirement that's bad we
- want to retire sooner
- um you'll notice that this grid is very
- sparse
- um so i'm going to pass a
- grid size of three and then you'll see
- now this will get more filled out as we
- add more inputs here in a moment but
- i think this makes more sense um
- for these data um
- and the other thing that we'll want to
- do is add some labels
- as well and it has to match up the keys
- match up again with the input names
- and then the values would be how you
- want it to look in the output so
- interest rate interest rate
- and then we can pass labels equals
- labels
- and we run these again now we can see in
- all the output
- that we're now getting the labels
- as well so it's starting to look clean
- um and the last thing we can do
- is add a number format um
- so here's your retirement not a currency
- we don't want a dollar sign
- and we can just have zero decimal places
- so then um we'll see now
- in the style data frames that we have no
- decimal places
- on the output
- so that looks good as far as the
- formatting
- options for the output now
- let's look at some more values of the
- inputs and look at more inputs
- so it can get tedious to type out all
- the different values that you might want
- to
- look at so that's why i like to use
- list comprehensions to uh write out the
- outputs
- so um if we want to look at
- um salaries and the range of
- say forty thousand to uh seventy
- thousand
- what we can do is uh
- we can just do a simple for i and range
- loop
- and multiply the result
- by ten thousand you know without the ten
- thousand it would be
- four five six seven then we just
- multiply it by ten thousand
- and then we have that range of salaries
- so i'm gonna put that
- in here as the starting salary
- then for interest rate um
- here we want to look at percentages so
- let's divide by 100
- and let's look from three to six
- percent so i'm going to take that and
- put that into the interest rate
- um and let's look at the other inputs as
- well
- uh so promos every and years and all
- these things
- should be matching up with the
- attributes
- on the model data
- so promos every n years
- let's look at um in the range
- of um
- how about from four to seven years
- uh so i'll put that there for promos
- everyone years
- um let's add cost of living raise
- um and cost of living raise that is
- another percentage we can divide by 100
- and let's go from a one percent to a
- three percent
- so i'm going to put that there um
- and we can add the promotion raise promo
- raise
- um and for that one um
- here we can look in increments of five
- percent
- let's look from ten percent to twenty
- percent in five percent increments
- um so let's keep that divided by a
- hundred since it's
- um a percentage and we're going to go
- from 10
- up to 25 but let's go in five
- steps so this is 10 15 20
- um of course you can write these out
- manually
- if you want just writing those numbers
- in
- but i like using the list comprehensions
- because it's also easy to go and adjust
- these ranges
- as well um
- let's see so let's also add the
- savings rate savings rate
- um and for savings rate let's go up to
- from 10 to 40
- and 10 increments um
- so that would be this 20 30
- um and let's look at the desire and cash
- so for desired cash um
- [Music]
- let's look at from
- a million dollars to 2.5 million dollars
- um in 500 000 increments so that's going
- to be uh
- 10 to 26 minutes of five
- and multiplying by a hundred thousand
- so that looks correct now we can take
- that and put that in there as well
- so then we have all these different
- values of the inputs that we want to
- look at
- um let's add their labels as well
- so promos every years
- promos every and years
- let's do the cost of living raise
- cost of living raise
- let's do the primaries
- motion rays
- i got interest rate already add savings
- rate
- savings rate and add desired cash
- okay um now we've got a bunch of
- different values of all these different
- inputs
- we've got all the labels we had all our
- options from before to make it look good
- let's go ahead and run this and now
- you'll see we have a lot more inputs
- that we're looking at we have 6 900
- different cases
- and now it actually takes some
- substantial time to run the model
- and we see that progress bar go by as
- it's running all these different input
- cases now it's
- done we look at this data frame
- um
- [Music]
- it's going to be
- [Music]
- you know having a lot more rows in it
- this time
- um and we should similarly see
- additional plots and style
- data frames all of this coming together
- um so there's a big advantage
- uh over excel in here in that you can
- pass as many possible inputs as you want
- you're not limited to just looking at
- two at once
- and it's going to be able to generate a
- lot of different results for you
- so now we've got
- we have the 6900 different runs of the
- model and data frame
- and we've got all these different
- combinations of the inputs
- and these flops so we can take any pair
- that we want to look at
- here it's all about the promotions
- promotional race promotions everyone
- years
- as you get quicker promotions we start
- to hit
- or sorry slower promotions than we get
- to longer years to retirement up to 40
- over here
- and as we get higher promotion raises
- then we get shorter years to retirement
- but we can see in the range of inputs
- that we're looking at
- it's not a very huge impact on the years
- to retirement
- so then you have the same information
- over here in the style
- data frames so you can really pick
- whichever one of the two
- you like better for showing the results
- you don't have to
- show both like i'm doing here
- and it would be good to at the end just
- put a description
- of your findings some of the notable
- things from the sensitivity analysis
- to kind of wrap everything together
- so that's adding sensitivity analysis to
- an existing model in python using the
- sensitivity
- package so that concludes
- our segment on exploring the parameter
- space
- we will examine a couple other
- techniques
- which explore the parameter space in the
- future lectures as well
- so thanks for listening and i'll see you
- next time
Lab Exercise - Adding Sensitivity Analysis to Project 1 - Python¶
Notes¶
The lab exercise here is the same as that we did for Excel but now just doing it in Python
You are free to use the manual approach or the sensitivity package but I would recommend the sensitivity package
Be sure to upgrade your sensitivity package before working on the exercise
The lecture on adding sensitivity analysis to the Python Dynamic Salary Retirement model will be very helpful for this
You may need to restructure your model before you can even begin adding sensitivity analysis. You must have a function which accepts the data and produces the final output from that data, and your functions must not access the overall model_data
Transcript¶
- hey everyone
- nick dear burtis here teaching you
- financial modeling today we're going to
- be
- talking about the lab exercise for
- sensitivity analysis
- in python as part of the lecture series
- on exploring the parameter space
- so we left off last time we had covered
- all the material on sensitivity analysis
- in python and now we're coming here to
- the last slide which has the lab
- exercise
- for python sensitivity analysis
- and that is analogous to the exercise we
- completed in excel
- you're going to be adding sensitivity
- analysis to your project
- 1 model um
- and so what we just went through with
- adding
- the uh sensitivity analysis to the
- dynamic salary retirement model in
- python
- is going to be really useful for
- completing this exercise so
- watch that carefully and carry out some
- of the same steps over there
- now since this is working with your own
- model
- there's a good chance that your model
- will not have the structure
- required to be able to extend it in any
- way
- if you're accessing the model data
- directly
- inside your logic rather than having a
- function which accepts an arbitrary data
- and working with that arbitrary data
- then this is not going to work you're
- going to have to go back
- and restructure it you should never be
- accessing that
- original model data from within your
- functions
- and you should have one function where
- you can pass it
- the data class and
- get the result of the entire model
- uh the mpv and cash flows um
- by just running a single function so
- you'll need to have both of those things
- in place before you can even go and
- start
- on this exercise so you should
- definitely go back and restructure
- things
- to be able to complete this and
- don't just think well my model is too
- far gone i'll just skip this lab
- exercise because
- as we go forward in the course we're
- gonna have more of these similar
- exercises of extending project one
- and so you really need to to rebuild it
- in a way
- that is going to be flexible to any
- extensions that you can add to it
- and i set it up this way because you
- want to always structure your models
- this way and this will really teach you
- why
- you want to structure them this way that
- way you can actually
- extend them rather than the model is
- what it is
- so that's the main idea here and then
- unlike the excel exercise where you're
- looking at doing just conditional
- formatting in a table
- here we're going to have the hexman plot
- as well as the styled
- data frame as the outputs
- so that's the lab exercise for the
- python sensitivity analysis and that
- wraps up this
- segment on exploring the parameter space
- so
- thanks for listening next time we'll be
- talking about
- probability modeling so i'll see you
- next time