Merge pull request #20 from BlockScience/staging
SimCAD Beta Pre-Release
This commit is contained in:
Joshua E. Jodesty
GitHub
commit
c1da72c1d2
|
|
@ -1,11 +1,15 @@
|
|||
.idea
|
||||
.ipynb_checkpoints
|
||||
.DS_Store
|
||||
.idea
|
||||
notebooks/.ipynb_checkpoints
|
||||
notebooks/multithreading.ipynb
|
||||
SimCAD.egg-info
|
||||
__pycache__
|
||||
Pipfile
|
||||
Pipfile.lock
|
||||
results
|
||||
.mypy_cache
|
||||
.mypy_cache
|
||||
*.csv
|
||||
*.txt
|
||||
simulations/.ipynb_checkpoints
|
||||
dist/SimCAD-0.1.tar.gz
|
||||
|
||||
build
|
||||
SimCAD.egg-info
|
||||
36
README.md
36
README.md
|
|
@ -1,37 +1,50 @@
|
|||
# SimCad
|
||||
**Warning**:
|
||||
**Do not** publish this package / software to **any** software repository **except** one permited by BlockScience.
|
||||
**Do not** publish this package / software to **any** software repository **except** one permitted by BlockScience.
|
||||
|
||||
**Description:**
|
||||
|
||||
SimCAD is a differential games based simulation software package for research, validation, and Computer \
|
||||
Aided Design of economic systems. An economic system is treated as a state based model and defined through a \
|
||||
set of endogenous and exogenous state variables which are updated through mechanisms and environmental \
|
||||
processes, respectively. Behavioral models, which may be deterministic or stochastic, provide the evolution of \
|
||||
the system within the action space of the mechanisms. Mathematical formulations of these economic games \
|
||||
treat agent utility as derived from state rather than direct from action, creating a rich dynamic modeling framework.
|
||||
|
||||
Simulations may be run with a range of initial conditions and parameters for states, behaviors, mechanisms, \
|
||||
and environmental processes to understand and visualize network behavior under various conditions. Support for \
|
||||
A/B testing policies, monte carlo analysis and other common numerical methods is provided.
|
||||
|
||||
**1. Install Dependencies:**
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
pip install .
|
||||
python3 setup.py sdist bdist_wheel
|
||||
```
|
||||
|
||||
**2. Configure Simulation:**
|
||||
|
||||
Example:
|
||||
Intructions:
|
||||
`/Simulation.md`
|
||||
|
||||
Examples:
|
||||
`/simulations/validation/*`
|
||||
|
||||
**3. Import SimCAD & Run Simulation:**
|
||||
|
||||
Example:
|
||||
`/simulations/sim_test.py`
|
||||
Examples: `/simulations/sim_test.py` or `/simulations/test.ipynb`
|
||||
|
||||
`/simulations/sim_test.py`:
|
||||
```python
|
||||
import pandas as pd
|
||||
from tabulate import tabulate
|
||||
|
||||
# The following imports NEED to be in the exact same order
|
||||
# The following imports NEED to be in the exact order
|
||||
from SimCAD.engine import ExecutionMode, ExecutionContext, Executor
|
||||
from simulations.validation import config_1, config_2
|
||||
from validation import config1, config2
|
||||
from SimCAD import configs
|
||||
|
||||
# ToDo: pass ExecutionContext with execution method as ExecutionContext input
|
||||
|
||||
exec_mode = ExecutionMode()
|
||||
|
||||
|
||||
print("Simulation Execution 1")
|
||||
print()
|
||||
first_config = [configs[0]] # from config1
|
||||
|
|
@ -39,7 +52,6 @@ single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
|
|||
run1 = Executor(exec_context=single_proc_ctx, configs=first_config)
|
||||
run1_raw_result, tensor_field = run1.main()
|
||||
result = pd.DataFrame(run1_raw_result)
|
||||
# result.to_csv('~/Projects/DiffyQ-SimCAD/results/config4.csv', sep=',')
|
||||
print()
|
||||
print("Tensor Field:")
|
||||
print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
|
||||
|
|
@ -64,4 +76,4 @@ for raw_result, tensor_field in run2.main():
|
|||
The above can be run in Jupyter.
|
||||
```bash
|
||||
jupyter notebook
|
||||
```
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
name = "SimCAD"
|
||||
configs = []
|
||||
#
|
||||
|
|
|
|||
|
|
@ -54,4 +54,4 @@ def exo_update_per_ts(ep):
|
|||
return f(step, sL, s, _input)
|
||||
else:
|
||||
return (y, s[y])
|
||||
return {es: ep_decorator(f, es) for es, f in ep.items()}
|
||||
return {es: ep_decorator(f, es) for es, f in ep.items()}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,6 @@ class Executor:
|
|||
self.main = self.execute
|
||||
|
||||
def execute(self):
|
||||
|
||||
config_proc = Processor()
|
||||
create_tensor_field = TensorFieldReport(config_proc).create_tensor_field
|
||||
|
||||
|
|
@ -73,4 +72,5 @@ class Executor:
|
|||
results = []
|
||||
for result, mechanism, ep in list(zip(simulations, mechanisms, eps)):
|
||||
results.append((flatten(result), create_tensor_field(mechanism, ep)))
|
||||
|
||||
return results
|
||||
|
|
|
|||
|
|
@ -17,4 +17,4 @@ def key_filter(l, keyname):
|
|||
|
||||
def rename(new_name, f):
|
||||
f.__name__ = new_name
|
||||
return f
|
||||
return f
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -0,0 +1,150 @@
|
|||
SOFTWARE LICENSE AGREEMENT
|
||||
|
||||
This Software License Agreement (the “Agreement”) is entered into as of December __ 2018, (the “Effective Date”) between
|
||||
Dapper Labs, Inc., a Canadian corporation having its principal place of business at 980-350 Howe Street,
|
||||
Vancouver, BC V6Z 1N9 (“DLI”) and BlockScience, Inc., a California corporation with an address at 471 McAuley Street,
|
||||
Oakland, CA 94609 (“BlockScience”). This Agreement includes the attached Exhibit A.
|
||||
|
||||
WHEREAS, DLI and BlockScience are parties to that certain Professional Services Agreement dated March 23, 2018 (the
|
||||
“PSA”), pursuant to which BlockScience performed and is currently performing professional services and other development
|
||||
work for DLI;
|
||||
|
||||
WHEREAS, as part of BlockScience’s performance under the PSA, BlockScience developed certain “behaviour archetypes” and
|
||||
“configuration of the Null Model”, which the parties agree are “Work Product” under the PSA;
|
||||
|
||||
WHEREAS, the parties agree that BlockScience’s proprietary SimCAD software tool is considered “Contractor Technology”
|
||||
under the PSA; and
|
||||
|
||||
WHEREAS, the parties wish to enter into this Agreement to clarify DLI’s rights to use the SimCAD software tool on a
|
||||
going-forward basis.
|
||||
|
||||
NOW, THEREFORE, for good and valuable consideration, the receipt and sufficiency of which is hereby acknowledged, DLI
|
||||
and BlockScience agree as follows:
|
||||
|
||||
1. DEFINITIONS
|
||||
|
||||
(a) “Affiliate” means any entity that, directly or indirectly through one or more intermediaries, controls, is
|
||||
controlled by, or is under common control with, DLI.
|
||||
|
||||
(b) “Documentation” means any manuals, documentation and other supporting materials related to the Software.
|
||||
Documentation is considered part of the related Software.
|
||||
|
||||
(c) “Intellectual Property Rights” means patent rights (including patent applications and disclosures), copyrights,
|
||||
trade marks, trade secrets, know-how and any other intellectual property rights recognized in any country or
|
||||
jurisdiction in the world.
|
||||
|
||||
(d) “Software” means the object and source code versions of BlockScience’s proprietary SimCAD software product more
|
||||
fully described in Exhibit A. Software includes the applicable Documentation, as well as any Updates.
|
||||
|
||||
(e) “Update” means any bug fix, error correction, patch, modification, enhancement, update, upgrade, replacement,
|
||||
successor product, new version, new release, or derivative work of or to the Software.
|
||||
|
||||
(f) “Zeus” means the decentralized synchronous computational network developed by DLI, as such name or reference may be
|
||||
changed from time to time at DLI’s sole discretion.
|
||||
|
||||
2. SOFTWARE LICENSE
|
||||
|
||||
(a) License Grant. BlockScience hereby grants to DLI and its Affiliates a worldwide, non-exclusive, royalty-free,
|
||||
irrevocable, perpetual license to (i) download, install, use, execute, access, copy, perform, and modify, the Software
|
||||
in connection with the Zeus project; (ii) distribute and display the Software internally amongst DLI and its Affiliates,
|
||||
its and their employees, contractors, and agents, subject to the use of reasonable efforts to maintain the confidential
|
||||
status of the non-public aspects of the Software display; and (iii) create derivative works of the Software in
|
||||
connection with the Zeus project, provided that any such derivative works may only be used in connection with the Zeus
|
||||
project. For the sake of clarity, nothing in this Agreement (including, without limitation, this Section 2) will create
|
||||
any liability to DLI for or restrict DLI’s ability to externally distribute python scripts containing the “input”
|
||||
configuration files specific to the Zeus project, as well as the notebooks with the resulting “output” data from the
|
||||
Software, all of which may be distributed, displayed, and shared publicly at DLI’s discretion.
|
||||
|
||||
(b) Ownership; Limited Rights. As between the parties, BlockScience owns and retains all right, title and interest in
|
||||
and to the Software, and all Intellectual Property Rights therein. DLI’s rights in the Software are limited to those
|
||||
expressly granted in Section 2(a) and in the PSA. BlockScience reserves all rights and licenses in the Software not
|
||||
expressly granted to DLI herein and in the PSA.
|
||||
|
||||
(c) Delivery. BlockScience will deliver a copy of the Software and Documentation to DLI on the Effective Date. The
|
||||
delivery may be made in electronic form, or via hardcopy medium (e.g., a CD).
|
||||
|
||||
(d) Updates. BlockScience will deliver Updates to DLI as and when such Updates become available. The obligation to
|
||||
deliver Updates will continue for as long as the PSA remains in force; upon termination or expiration of the PSA,
|
||||
BlockScience’s obligation to provide Updates will automatically terminate.
|
||||
|
||||
(e) Support. BlockScience will provide reasonable technical support for the Software, to help DLI manage any support
|
||||
issues that arise. The obligation to provide support will continue for as long as the PSA remains in force; upon
|
||||
termination or expiration of the PSA, BlockScience’s obligation to provide support will automatically terminate.
|
||||
|
||||
3. NO FEES.
|
||||
|
||||
There are no fees owed by DLI for the license granted or the Updates or support provided by BlockScience
|
||||
pursuant to this Agreement. Each party will bear its own costs and expenses arising out of or relating to its
|
||||
obligations, efforts and performance under this Agreement.
|
||||
|
||||
4. LIMITED WARRANTY; DISCLAIMER
|
||||
|
||||
(a) Limited Warranty. BlockScience represents and warrants as follows: (i) that it has the right to enter into this
|
||||
Agreement, and to perform its obligations hereunder, without violating the terms of any other agreement; (ii) that the
|
||||
Software, and any Updates, do not and will not infringe, violate, or misappropriate the Intellectual Property Rights of
|
||||
any third party; (iii) that the Software and any Updates do not and will not contain any virus, malware, spyware, trojan
|
||||
horse, or other malicious code; and (iv) that the Software and each Update will substantially conform to its
|
||||
Documentation.
|
||||
|
||||
(b) Disclaimer. EXCEPT AS OTHERWISE SET FORTH IN THIS AGREEMENT, BLOCKSCIENCE DISCLAIMS ALL OTHER WARRANTIES, EXPRESS OR
|
||||
IMPLIED, RELATED TO THE SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
|
||||
PURPOSE.
|
||||
|
||||
5. TERM & TERMINATION
|
||||
|
||||
(a) Term. This Agreement begins on the Effective Date, and will continue in effect until one of us terminates it in
|
||||
accordance with Section 5(b).
|
||||
|
||||
(b) Termination for Breach. Either party may terminate this Agreement if the other party breaches any material term or
|
||||
condition of this Agreement, and the breaching party fails to cure the breach within thirty (30) days of receiving
|
||||
written notice of it.
|
||||
|
||||
(c) Survival. Sections 2 through 7 will survive termination or expiration of this Agreement.
|
||||
|
||||
6. INDEMNIFICATION.
|
||||
|
||||
BlockScience will defend, indemnify, and hold DLI harmless from and against any claim, damage, loss,
|
||||
liability, expense and cost (including, without limitation, reasonable attorneys’ fees) incurred by or brought against
|
||||
DLI arising out of or related to: (i) any claim that the Software infringes or misappropriates the Intellectual Property
|
||||
Rights of that third party; or (ii) BlockScience’s breach of its limited warranties in Section 4(a).
|
||||
|
||||
7. GENERAL TERMS
|
||||
|
||||
(a) Entire Agreement; Waiver. This Agreement is the entire understanding of the parties, and supersedes any and all
|
||||
prior agreements or understandings between the parties as to its subject matter. It may be amended or modified, or
|
||||
provisions waived, only in a writing signed by both parties. The waiver of a breach of any provision of this Agreement
|
||||
will not operate or be interpreted as a waiver of any other or subsequent breach.
|
||||
|
||||
(b) Acknowledgement. BlockScience acknowledges and agrees that the “behaviour archetypes” and “configuration of the Null
|
||||
Model” referenced in the PSA are considered “Work Product” under the PSA.
|
||||
|
||||
(c) Governing Law. This Agreement will be construed, interpreted and applies in accordance with the internal laws of
|
||||
British Columbia, Canada (excluding its body of law controlling conflicts of law). Any legal action or proceeding
|
||||
arising under or related to this Agreement will be brought exclusively in the federal or provincial courts located in
|
||||
Vancouver, British Columbia, and the parties irrevocably consent to personal jurisdiction and venue there.
|
||||
|
||||
(d) Severability. If any provision of this Agreement is held to be invalid or unenforceable for any reason, that
|
||||
provision will be enforced to the maximum extent permitted by law, and the remaining provisions will continue in full
|
||||
force and effect.
|
||||
|
||||
(e) Miscellaneous. This Agreement may be executed in one or more counterparts, with the same effect as if the parties
|
||||
had signed the same document. Each counterpart so executed will be deemed to be an original, and all such counterparts
|
||||
will be construed together and will constitute one Agreement. The prevailing party in any action or legal proceeding
|
||||
arising out of this Agreement will be entitled to recover from the other party all reasonable costs and expenses
|
||||
incurred in connection with such action or proceeding, including reasonable attorneys’ fees and court costs. In the
|
||||
event of a direct conflict between the terms of this Agreement and the PSA with respect to the DLI’s rights in and to
|
||||
the Software, the terms of this Agreement will control.
|
||||
|
||||
EXHIBIT A
|
||||
|
||||
SOFTWARE
|
||||
|
||||
Software Name: SimCAD tool
|
||||
|
||||
Software Description: SimCAD is a Monte-Carlo based simulation software package for research, validation, and
|
||||
Computer Aided Design of economic systems. An economic system is treated as a state based model and defined
|
||||
through a set of endogenous and exogenous state variables which are updated through mechanisms and
|
||||
environmental processes, respectively. Behavioral models, which may be deterministic or stochastic, provide the
|
||||
evolution of the system within the action space of the mechanisms. Simulations can be run with a range of initial
|
||||
conditions and parameters for states, behaviors, mechanisms, and environmental processes to understand and
|
||||
visualize network behavior under various conditions.
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
TRIAL LICENSE AGREEMENT
|
||||
|
||||
BACKGROUND
|
||||
|
||||
Company has developed and intends to market and license a certain software product and service called ”SimCAD” which,
|
||||
among other things, is a scientific engineering simulation tool (“Software”). Company wishes to provide access, on a
|
||||
trial basis, to users of a “beta” version of the Software to test and provide feedback to Company. Licensee wishes to
|
||||
participate in Company’s beta trial of the Software and to provide feedback to Company with respect to Licensee’s use
|
||||
thereof.
|
||||
|
||||
Accordingly, the parties hereby agree as follows:
|
||||
|
||||
1. BETA PRODUCT.
|
||||
|
||||
This Agreement applies to any prerelease version of the Software and any updates and changes thereto during the Term
|
||||
(collectively, “Beta Product”). As an essential condition of this Agreement, Licensee understands and acknowledges that:
|
||||
(a) Licensee is participating in a beta test of the Beta Product; (b) the Beta Product has not been field tested or
|
||||
trialed; and (c) the Beta Product may not operate properly or be error free and may not perform all functions for
|
||||
which it is intended or represented.
|
||||
|
||||
2. FEEDBACK.
|
||||
|
||||
As a condition of this Agreement, during the Term of this Agreement, Licensee agrees to provide Company with comments,
|
||||
feedback, criticisms, and suggestions for changes to the Beta Product (“Feedback”), and to help Company identify errors
|
||||
or malfunctions, and performance issues, in the operation of the Beta Product, as Company may reasonably request. All
|
||||
rights to any Feedback or other intellectual property derived from Licensee’s use of or relating to the Beta Product,
|
||||
as well any data collected from the use of the Beta Product, belong solely to Company and Licensee hereby irrevocably
|
||||
assigns all such rights to Company. Company reserves the right to use all Feedback and data collected as a result of the
|
||||
use of the Beta Product to advertise and promote the Company and the Software.
|
||||
|
||||
3. LICENSE AND RESERVATION OF RIGHTS.
|
||||
|
||||
3.1 Subject to the terms and conditions set forth in this Agreement, Company hereby grants Licensee, and Licensee
|
||||
accepts, during the Term, a nonexclusive, royaltyfree, revocable, nontransferable, limited license to access and use
|
||||
the Beta Product for its internal, noncommercial use for evaluation purposes only, and to give permission to employees
|
||||
of Licensee and employees of Licensee’s subsidiaries (“Permitted Users”) to use the Beta Product in accordance with the
|
||||
foregoing.
|
||||
|
||||
3.2 The Beta Product and the Software comprise the intellectual property of Company. All right, title and interest in
|
||||
and to the Beta Product (and, more generally, in and to the Software), and to all Feedback and data arising from its
|
||||
use, in whole or in part, and all patent, copyright, trademarks, trade secret and all other intellectual and industrial
|
||||
property rights therein and the structure, sequence and organization of same, and the media on which such material is
|
||||
contained belong exclusively to Company. Licensee and its Permitted Users will not, directly or indirectly: reverse
|
||||
engineer, decompile, disassemble or otherwise attempt to discover the source code, object code or underlying structure,
|
||||
ideas, knowhow or algorithms relevant to the Beta Product; modify, adapt, alter, edit, correct, translate, publish,
|
||||
sell, transfer, assign, convey, rent, lease, loan, pledge, sublicense, distribute, export, enhance or create derivative
|
||||
works based on the Beta Product; or remove, alter, cover or otherwise obscure any proprietary notices or labels
|
||||
displayed on or within the Beta Product any documentation relating thereto.
|
||||
|
||||
4. DISCLAIMER.
|
||||
|
||||
4.1 COMPANY MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, WITH RESPECT TO THE BETA PRODUCT,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE AVAILABILITY, QUALITY OR PERFORMANCE OF THE BETA PRODUCT. COMPANY SPECIFICALLY
|
||||
DISCLAIMS ALL EXPRESS, STATUTORY AND IMPLIED WARRANTIES AND CONDITIONS, INCLUDING, WITHOUT LIMITATION (A) THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT, (B) ANY WARRANTIES AGAINST HIDDEN
|
||||
OR LATENT DEFECTS, (C) AND ANY WARRANTIES AND CONDITIONS ARISING OUT OF COURSE OF DEALING OR USAGE OF TRADE AND (D) ANY
|
||||
WARRANTY OR REPRESENTATION THAT THE BETA PRODUCT IS ERRORFREE, VIRUSFREE, SECURE, UNINTERRUPTED, OR FREE FROM
|
||||
UNAUTHORIZED ACCESS (INCLUDING, BUT NOT LIMITED TO, THIRD PARTY HACKERS OR DENIAL OF SERVICE ATTACKS). THE BETA PRODUCT
|
||||
IS SUPPLIED ON AN “AS IS”, “AS AVAILABLE” BASIS WITHOUT WARRANTY.
|
||||
|
||||
4.2 NEITHER PARTY SHALL BE LIABLE FOR SPECIAL, INCIDENTAL, PUNITIVE, CONSEQUENTIAL OR INDIRECT DAMAGES OR LOSS
|
||||
(INCLUDING DEATH AND PERSONAL INJURY), IRRESPECTIVE OF THEIR CAUSE, NOTWITHSTANDING THAT A PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH LOSS OR DAMAGE, NOR FOR ANY CLAIMS FOR SUCH LOSS OR DAMAGE INSTITUTED AGAINST A PARTY OR ITS
|
||||
CUSTOMERS BY ANY THIRD PARTY.
|
||||
|
||||
5. CONFIDENTIALITY
|
||||
|
||||
5.1 All Confidential Information disclosed by either party shall be kept by the receiving party in strict confidence and
|
||||
shall not be disclosed to any third party without the disclosing party’s express written consent. For purposes of this
|
||||
Agreement, “Confidential Information” means all information regarding either party’s business which has been marked or
|
||||
is otherwise communicated as being “proprietary” or “confidential” or which reasonably should be known by the receiving
|
||||
party to be proprietary or confidential information. Without limiting the generality of the foregoing, Confidential
|
||||
Information of Company includes nonpublic information regarding features, functionality and performance of the Beta
|
||||
Product, including all Feedback and related data. Notwithstanding the foregoing, each party’s confidentiality
|
||||
obligations hereunder shall not apply to information that: (a) is already known to the receiving party without a
|
||||
preexisting restriction as to disclosure; (b) is or becomes publicly available without fault of the receiving party;
|
||||
(c) is rightfully obtained by the receiving party from a third party without restriction as to disclosure, or is
|
||||
approved for release by written authorization of the disclosing party; (d) is developed independently by the receiving
|
||||
party without use of the disclosing party’s Confidential Information; or (e) is required to be disclosed by law or
|
||||
regulation, including, but not limited to, supplying such information or making such statements or disclosures relating
|
||||
to this Agreement before any competent court, governmental agency or authority in response to a lawful requirement or
|
||||
request from a court of governmental agency or authority, provided that the disclosing party shall give the other party
|
||||
prompt notice of such request, to the extent practicable, so that the other party may seek (at its sole cost and
|
||||
expense) an appropriate protective order or similar relief.
|
||||
|
||||
5.2 In the event of a breach of Sections 2, 3 or this Section 5, the nonbreaching party shall be entitled to seek
|
||||
equitable relief to protect its interests, including, but not limited to, injunctive relief. In the event of expiration
|
||||
or earlier termination of this Agreement, each party shall immediately return to the other party such other party’s
|
||||
Confidential Information, or at such other party’s option, destroy any remaining Confidential Information and certify
|
||||
that such destruction has taken place.
|
||||
|
||||
6. FEES; EXPENSES.
|
||||
|
||||
Neither party shall be entitled to any compensation in connection with this Agreement or its use or provision of the
|
||||
Beta Product. Each party shall bear its own costs and expenses arising from this Agreement and its use or provision of
|
||||
the Beta Product, as the case may be.
|
||||
|
||||
7. TERM OF AGREEMENT.
|
||||
|
||||
This Agreement shall begin on the Effective Date and shall continue until it has been terminated (such period, the
|
||||
“Term”). Either party shall have the right to terminate this Agreement at any time on one (1) month written notice to
|
||||
the other party, or in the case of a breach of this Agreement by Licensee or its Permitted Users, Company may terminate
|
||||
this Agreement immediately on written notice to Licensee. Upon termination of this Agreement, all rights granted to
|
||||
Licensee (and any Permitted User) under this Agreement will immediately terminate and Licensee (and all Permitted Users)
|
||||
must immediately cease all use of the Beta Product at such time. Notwithstanding any termination of this Agreement,
|
||||
Sections 2, 3.2, 4, 5, 6, this Section 7 and Section 8 shall survive and remain binding on the parties.
|
||||
|
||||
8. MISCELLANEOUS.
|
||||
|
||||
This Agreement shall be governed by and construed in accordance with the laws of the State of New York. All disputes
|
||||
relating to this Agreement shall be resolved in the federal and state courts of New York County, New York and the
|
||||
parties submit to the jurisdiction of such courts. This Agreement does not create any agency, partnership, or joint
|
||||
venture relationship between Licensee and Company. This Agreement is the entire understanding of the parties with
|
||||
respect to the subject matter hereof and supersedes any previous or contemporaneous communications, representations,
|
||||
warranties, discussions, arrangements or commitments, whether oral or written with respect to such subject matter. This
|
||||
Agreement cannot be amended except by a written amendment that expressly refers to this Agreement and is signed by an
|
||||
authorized representative of each party. This Agreement may be executed in one or more counterparts, including via
|
||||
facsimile or email (or any other electronic means such as “.pdf” or “.tiff” files), each of which shall be deemed an
|
||||
original, and all of which shall constitute one and the same Agreement.
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(\"Simulation Run 2: Pairwise Execution\")\n",
|
||||
"print()\n",
|
||||
"multi_proc_ctx = ExecutionContext(exec_mode.multi_proc)\n",
|
||||
"run2 = Executor(multi_proc_ctx, configs)\n",
|
||||
"run2_raw_results = run2.main()\n",
|
||||
"for raw_result in run2_raw_results:\n",
|
||||
" result = pd.DataFrame(raw_result)\n",
|
||||
" print(tabulate(result, headers='keys', tablefmt='psql'))\n",
|
||||
"print()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(\"Simulation Run 1\")\n",
|
||||
"print()\n",
|
||||
"single_config = [configs[0]]\n",
|
||||
"single_proc_ctx = ExecutionContext(exec_mode.single_proc)\n",
|
||||
"run1 = Executor(single_proc_ctx, single_config)\n",
|
||||
"run1_raw_result = run1.main()\n",
|
||||
"result = pd.DataFrame(run1_raw_result)\n",
|
||||
"result"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"collapsed": true
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import pandas as pd\n",
|
||||
"from tabulate import tabulate\n",
|
||||
"\n",
|
||||
"from SimCAD.engine import ExecutionMode, ExecutionContext, Executor\n",
|
||||
"from sandboxUX import config1, config2\n",
|
||||
"from SimCAD import configs\n",
|
||||
"\n",
|
||||
"# ToDo: pass ExecutionContext with execution method as ExecutionContext input\n",
|
||||
"\n",
|
||||
"exec_mode = ExecutionMode()"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 2",
|
||||
"language": "python",
|
||||
"name": "python2"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 2
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython2",
|
||||
"version": "2.7.6"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 0
|
||||
}
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
pathos
|
||||
pipenv
|
||||
fn
|
||||
tabulate
|
||||
22
setup.py
22
setup.py
|
|
@ -1,11 +1,23 @@
|
|||
from setuptools import setup
|
||||
from setuptools import setup, find_packages
|
||||
|
||||
long_description = "SimCAD is a differential games based simulation software package for research, validation, and \
|
||||
Computer Aided Design of economic systems. An economic system is treated as a state based model and defined through \
|
||||
a set of endogenous and exogenous state variables which are updated through mechanisms and environmental processes, \
|
||||
respectively. Behavioral models, which may be deterministic or stochastic, provide the evolution of the system \
|
||||
within the action space of the mechanisms. Mathematical formulations of these economic games treat agent utility as \
|
||||
derived from state rather than direct from action, creating a rich dynamic modeling framework. Simulations may be \
|
||||
run with a range of initial conditions and parameters for states, behaviors, mechanisms, and environmental \
|
||||
processes to understand and visualize network behavior under various conditions. Support for A/B testing policies, \
|
||||
monte carlo analysis and other common numerical methods is provided."
|
||||
|
||||
setup(name='SimCAD',
|
||||
version='0.1',
|
||||
description='Sim-Cad Enigne',
|
||||
description="SimCAD: a differential games based simulation software package for research, validation, and \
|
||||
Computer Aided Design of economic systems",
|
||||
long_description = long_description,
|
||||
url='https://github.com/BlockScience/DiffyQ-SimCAD',
|
||||
author='Joshua E. Jodesty',
|
||||
author_email='joshua@block.science',
|
||||
# license='?????',
|
||||
packages=['SimCAD'],
|
||||
zip_safe=False)
|
||||
license='licenses',
|
||||
packages=find_packages() #['SimCAD']
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,494 +0,0 @@
|
|||
from decimal import Decimal
|
||||
import numpy as np
|
||||
|
||||
from SimCAD import Configuration, configs
|
||||
from SimCAD.configuration import exo_update_per_ts, bound_norm_random, \
|
||||
ep_time_step
|
||||
|
||||
seed = {
|
||||
'z': np.random.RandomState(1)
|
||||
# 'a': np.random.RandomState(2),
|
||||
# 'b': np.random.RandomState(3),
|
||||
# 'c': np.random.RandomState(3)
|
||||
}
|
||||
|
||||
#Signals
|
||||
# Pr_signal
|
||||
#if s['P_Ext_Markets'] != 0:
|
||||
#Pr_signal = s['Z']/s['P_Ext_Markets']
|
||||
#else Pr_signal = 0
|
||||
# if Pr_signal < s['Z']/s['Buy_Log']:
|
||||
beta = Decimal('0.25') #agent response gain
|
||||
beta_LT = Decimal('0.1') #LT agent response gain
|
||||
alpha = Decimal('0.091') #21 day EMA forgetfullness between 0 and 1, closer to 1 discounts older obs quicker, should be 2/(N+1)
|
||||
max_withdraw_factor = Decimal('0.9')
|
||||
external_draw = Decimal('0.01') # between 0 and 1 to draw Buy_Log to external
|
||||
|
||||
# Stochastic process factors
|
||||
correction_factor = Decimal('0.01')
|
||||
volatility = Decimal('5.0')
|
||||
|
||||
|
||||
# Buy_Log_signal =
|
||||
# Z_signal =
|
||||
# Price_signal =
|
||||
# TDR_draw_signal =
|
||||
# P_Ext_Markets_signal =
|
||||
|
||||
# Behaviors per Mechanism
|
||||
|
||||
# BEHAVIOR 1: EMH Trader
|
||||
EMH_portion = Decimal('0.250')
|
||||
EMH_Ext_Hold = Decimal('42000.0')
|
||||
|
||||
def b1m1(step, sL, s):
|
||||
# y = 'P_Ext_Markets'
|
||||
# Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# if Psignal_ext < Psignal_int:
|
||||
# return beta*(Psignal_int - Psignal_ext) * s['Z'] # Deposited amount in TDR
|
||||
# else:
|
||||
# return 0 # Decimal(0.000001)
|
||||
# return (y,x)
|
||||
theta = (s['Z']*EMH_portion*s['Price'])/(s['Z']*EMH_portion*s['Price'] + EMH_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return beta * theta*EMH_Ext_Hold * s['P_Ext_Markets']/(s['Price']*EMH_portion*(1-theta))
|
||||
elif s['Price'] > (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return 0
|
||||
else:
|
||||
return 0
|
||||
|
||||
def b1m2(step, sL, s):
|
||||
theta = (s['Z']*EMH_portion*s['Price'])/(s['Z']*EMH_portion*s['Price'] + EMH_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return 0
|
||||
elif s['Price'] > (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return beta * theta*EMH_Ext_Hold * s['P_Ext_Markets']/(s['Price']*EMH_portion*(1-theta))
|
||||
else:
|
||||
return 0
|
||||
|
||||
# BEHAVIOR 3: Herding
|
||||
|
||||
|
||||
# BEHAVIOR 4: HODLers
|
||||
HODL_belief = Decimal('10.0')
|
||||
HODL_portion = Decimal('0.250')
|
||||
HODL_Ext_Hold = Decimal('4200.0')
|
||||
|
||||
def b4m2(step, sL, s):
|
||||
theta = (s['Z']*HODL_portion*s['Price'])/(s['Z']*HODL_portion*s['Price'] + HODL_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < 1/HODL_belief*(theta*HODL_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*HODL_portion*(1-theta)):
|
||||
return beta * theta*HODL_Ext_Hold * s['P_Ext_Markets']/(s['Price']*HODL_portion*(1-theta))
|
||||
elif s['Price'] > (theta*HODL_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*HODL_portion*(1-theta)):
|
||||
return 0
|
||||
else:
|
||||
return 0
|
||||
|
||||
|
||||
# BEHAVIOR 2: Withdraw TDR and burn Zeus
|
||||
# Selling Agent- Arbitrage on TDR ext v TDR int signals
|
||||
# def b2m1(step, sL, s):
|
||||
# Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# if Psignal_ext > Psignal_int:
|
||||
# # withdrawn amount in TDR, subject to TDR limit
|
||||
# return - np.minimum(beta*(Psignal_ext - Psignal_int) * s['Z'],s['Buy_Log']*max_withdraw_factor)
|
||||
# else:
|
||||
# return 0 #- Decimal(0.000001)
|
||||
# return 0
|
||||
|
||||
# BEHAVIOR 1: Deposit TDR and mint Zeus
|
||||
# Buying Agent- Arbitrage on Price and Z signals
|
||||
# def b1m2(step, sL, s):
|
||||
# # Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# # Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# # if Psignal_ext > Psignal_int:
|
||||
# # # withdrawn amount in TDR, subject to TDR limit
|
||||
# # return - np.minimum(beta*(Psignal_ext - Psignal_int) * s['Z'],s['Buy_Log']*max_withdraw_factor)
|
||||
# # else:
|
||||
# # return 0 #- Decimal(0.000001)
|
||||
# #
|
||||
# # LT more valuable than ST = deposit TDR and mint Z
|
||||
# Psignal_LT = s['Price'] / s['Z']
|
||||
# if Psignal_LT > 1:
|
||||
# return beta_LT*(Psignal_LT - 1) * s['Z']
|
||||
# else:
|
||||
# return 0
|
||||
|
||||
# Behavior will go here- b2m2, putting in mech 3: b1m3 for debugging
|
||||
# def b2m2(step, sL, s):
|
||||
# # Psignal_LT = s['Price'] / s['Z']
|
||||
# # if Psignal_LT > 1:
|
||||
# test = np.arange(1,10)
|
||||
# return test
|
||||
|
||||
# Selling Agent- Arbitrage on Price and Z signals
|
||||
# def b1m3(step, sL, s):
|
||||
# Psignal_LT = s['Price'] / s['Z']
|
||||
# if Psignal_LT < 1:
|
||||
# return - np.minimum(beta_LT*(Psignal_LT - 1) * s['Z'], s['Z']*max_withdraw_factor)
|
||||
# else:
|
||||
# return 0
|
||||
|
||||
|
||||
# def b2m3(step, sL, s):
|
||||
# return 0
|
||||
|
||||
def dummy_behavior(step, sL, s):
|
||||
return 0
|
||||
def s1_dummy(step, sL, s, _input):
|
||||
y = 'Z'
|
||||
x = s['Z']
|
||||
return (y, x)
|
||||
def s2_dummy(step, sL, s, _input):
|
||||
y = 'Price'
|
||||
x = s['Price']
|
||||
return (y, x)
|
||||
def s3_dummy(step, sL, s, _input):
|
||||
y = 'Buy_Log'
|
||||
x = s['Buy_Log']
|
||||
return (y, x)
|
||||
def s4_dummy(step, sL, s, _input):
|
||||
y = 'Sell_Log'
|
||||
x = s['Sell_Log']
|
||||
return (y, x)
|
||||
def s5_dummy(step, sL, s, _input):
|
||||
y = 'Trans'
|
||||
x = s['Trans']
|
||||
return (y, x)
|
||||
def s6_dummy(step, sL, s, _input):
|
||||
y = 'P_Ext_Markets'
|
||||
x = s['P_Ext_Markets']
|
||||
return (y, x)
|
||||
# Internal States per Mechanism
|
||||
# Deposit TDR/Mint Zeus
|
||||
# def s1m1(step, sL, s, _input):
|
||||
# s['Z'] = s['Z'] + _input
|
||||
|
||||
|
||||
# STATES
|
||||
|
||||
# ZEUS Fixed Supply
|
||||
def s1m1(step, sL, s, _input):
|
||||
y = 'Z'
|
||||
x = s['Z'] #+ _input # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
def s2m1(step, sL, s, _input):
|
||||
y = 'Price'
|
||||
x = (s['P_Ext_Markets'] - _input) /s['Z'] *10000
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
def s3m1(step, sL, s, _input):
|
||||
y = 'Buy_Log'
|
||||
x = _input # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
def s4m2(step, sL, s, _input):
|
||||
y = 'Sell_Log'
|
||||
x = _input # / Psignal_int
|
||||
print('s4m2 ',type(_input))
|
||||
return (y, x)
|
||||
|
||||
def s3m3(step, sL, s, _input):
|
||||
y = 'Buy_Log'
|
||||
x = s['Buy_Log'] + _input # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
# Price Update
|
||||
def s2m3(step, sL, s, _input):
|
||||
print('s2m3 ')
|
||||
print(type(s['Sell_Log']))
|
||||
print(type(s['Z']))
|
||||
|
||||
y = 'Price'
|
||||
x = s['Price'] + s['Buy_Log']/s['Z'] - s['Sell_Log']/s['Z']
|
||||
#+ np.divide(s['Buy_Log'],s['Z']) - np.divide() # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
|
||||
|
||||
def s6m1(step, sL, s, _input):
|
||||
y = 'P_Ext_Markets'
|
||||
x = s['P_Ext_Markets'] - _input
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
def s2m2(step, sL, s, _input):
|
||||
y = 'Price'
|
||||
x = (s['P_Ext_Markets'] - _input) /s['Z'] *10000
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
# def s1m1(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] + _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m1(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m1(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] + _input # Input already in TDR * s['Z']
|
||||
# return (y, x)
|
||||
|
||||
# # Withdraw TDR/Burn Zeus
|
||||
# def s1m2(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] #+ _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m2(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m2(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] + _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s1m3(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] #+ _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m3(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m3(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] #+ _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s3m4(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log']*(1-external_draw) + s['Sell_Log']*external_draw # _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s1m3(step, sL, s, _input):
|
||||
# s['Z'] = s['Z'] + _input
|
||||
# def s2m3(step, sL, s, _input):
|
||||
# s['Price'] = s['Price'] + _input
|
||||
|
||||
# Exogenous States
|
||||
proc_one_coef_A = -125
|
||||
proc_one_coef_B = 125
|
||||
# def es3p1(step, sL, s, _input):
|
||||
# s['s3'] = s['s3'] * bound_norm_random(seed['a'], proc_one_coef_A, proc_one_coef_B)
|
||||
# def es4p2(step, sL, s, _input):
|
||||
# s['P_Ext_Markets'] = s['P_Ext_Markets'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B)
|
||||
# def es5p2(step, sL, s, _input): # accept timedelta instead of timedelta params
|
||||
# s['timestamp'] = ep_time_step(s, s['timestamp'], seconds=1)
|
||||
def es3p1(step, sL, s, _input):
|
||||
y = 's3'
|
||||
x = s['s3'] + 1
|
||||
return (y, x)
|
||||
# def es4p2(step, sL, s, _input):
|
||||
# y = 'P_Ext_Markets'
|
||||
# # bound_norm_random defined in utils.py
|
||||
|
||||
# #x = s['P_Ext_Markets'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B)
|
||||
# expected_change = correction_factor*(s['P_Ext_Markets']-s['Buy_Log'])
|
||||
# vol = np.random.randint(1,volatility)
|
||||
# change = expected_change * vol
|
||||
# # change_float = (np.random.normal(expected_change,volatility*expected_change) #Decimal('1.0')
|
||||
# #change = Decimal.from_float(change_float)
|
||||
# x = s['P_Ext_Markets'] + change
|
||||
|
||||
# return (y, x)
|
||||
|
||||
# A change in belief of actual price, passed onto behaviors to make action
|
||||
def es4p2(step, sL, s, _input):
|
||||
y = 'P_Ext_Markets'
|
||||
x = s['P_Ext_Markets'] + bound_norm_random(seed['z'], proc_one_coef_A, proc_one_coef_B)
|
||||
|
||||
return (y,x)
|
||||
|
||||
|
||||
def es5p2(step, sL, s, _input): # accept timedelta instead of timedelta params
|
||||
y = 'timestamp'
|
||||
x = ep_time_step(s, s['timestamp'], seconds=1)
|
||||
return (y, x)
|
||||
#Environment States
|
||||
# def stochastic(reference, seed, correction = 0.01):
|
||||
# series = np.zeros(len(reference))
|
||||
# series[0] = reference[0]
|
||||
# for i in range(1,len(reference)):
|
||||
# expected_change = correction*(reference[i]-series[i-1])
|
||||
# normalized_expected_change = np.abs(expected_change)*(reference[i])/(reference[i-1])
|
||||
# seed_int = seed.randint(1,10)
|
||||
# change = np.random.normal(expected_change,seed_int*normalized_expected_change)
|
||||
|
||||
# series[i] = series[i-1]+change
|
||||
# # avoid negative series returns
|
||||
# if series[i] <= 0:
|
||||
# series[i] = .01
|
||||
# #series[i] = series[i-1]+change
|
||||
|
||||
# return [series,seed_int]
|
||||
# ref3 = np.arange(1,1000)*.1
|
||||
# test = stochastic(ref3,seed['b'])
|
||||
|
||||
# def env_a(ref3,seed['b']):
|
||||
# return stochastic(ref3,seed['b'])
|
||||
def env_a(x):
|
||||
return 100
|
||||
def env_b(x):
|
||||
return 21000000
|
||||
# def what_ever(x):
|
||||
# return x + 1
|
||||
|
||||
# Genesis States
|
||||
state_dict = {
|
||||
'Z': Decimal(21000000.0),
|
||||
'Price': Decimal(100.0), # Initialize = Z for EMA
|
||||
'Buy_Log': Decimal(0.0),
|
||||
'Sell_Log': Decimal(0.0),
|
||||
'Trans': Decimal(0.0),
|
||||
'P_Ext_Markets': Decimal(25000.0),
|
||||
|
||||
# 's2': Decimal(0.0),
|
||||
# 's3': Decimal(0.0),
|
||||
# 's4': Decimal(0.0),
|
||||
'timestamp': '2018-10-01 15:16:24'
|
||||
}
|
||||
|
||||
# exogenous_states = {
|
||||
# # "s3": es3p1,
|
||||
# "P_Ext_Markets": es4p2,
|
||||
# "timestamp": es5p2
|
||||
# }
|
||||
|
||||
exogenous_states = exo_update_per_ts(
|
||||
{
|
||||
# "s3": es3p1,
|
||||
"P_Ext_Markets": es4p2,
|
||||
"timestamp": es5p2
|
||||
}
|
||||
)
|
||||
|
||||
env_processes = {
|
||||
# "s3": env_proc('2018-10-01 15:16:25', env_a),
|
||||
# "P_Ext_Markets": env_proc('2018-10-01 15:16:25', env_b)
|
||||
}
|
||||
|
||||
# test return vs. non-return functions as lambdas
|
||||
# test fully defined functions
|
||||
mechanisms = {
|
||||
"m1": {
|
||||
"behaviors": {
|
||||
"b1": b1m1, # lambda step, sL, s: s['s1'] + 1,
|
||||
# "b2": b2m1
|
||||
},
|
||||
"states": {
|
||||
"Z": s1m1,
|
||||
"Price": s2_dummy,
|
||||
"Buy_Log": s3m1,
|
||||
"Sell_Log":s4_dummy,
|
||||
"Trans": s5_dummy,
|
||||
"P_Ext_Markets": s6_dummy
|
||||
}
|
||||
},
|
||||
"m2": {
|
||||
"behaviors": {
|
||||
"b1": b1m2,
|
||||
"b4": b4m2
|
||||
},
|
||||
"states": {
|
||||
"Z": s1_dummy,
|
||||
"Price": s2_dummy,
|
||||
"Buy_Log": s3_dummy,
|
||||
"Sell_Log":s4m2,
|
||||
"Trans": s5_dummy,
|
||||
"P_Ext_Markets": s6_dummy
|
||||
}
|
||||
},
|
||||
"m3": {
|
||||
"behaviors": {
|
||||
# "b1": b1m2,
|
||||
# "b4": b4m2
|
||||
},
|
||||
"states": {
|
||||
"Z": s1_dummy,
|
||||
"Price": s2m3,
|
||||
"Buy_Log": s3_dummy,
|
||||
"Sell_Log":s4_dummy,
|
||||
"Trans": s5_dummy,
|
||||
"P_Ext_Markets": s6_dummy
|
||||
}
|
||||
},
|
||||
# "m3": {
|
||||
# "behaviors": {
|
||||
# "b1": b1m3,
|
||||
# "b2": b2m3
|
||||
# },
|
||||
# "states": {
|
||||
# "Z": s1m3,
|
||||
# "Price": s2m3,
|
||||
# "Buy_Log": s3m3,
|
||||
# "Sell_Log": s4_dummy,
|
||||
# "Trans": s5_dummy,
|
||||
# "P_Ext_Markets": s6_dummy
|
||||
# }
|
||||
# },
|
||||
# "m4": {
|
||||
# "behaviors": {
|
||||
# "dummy": dummy_behavior
|
||||
# },
|
||||
# "states": {
|
||||
# "Z": s1_dummy,
|
||||
# "Price": s2_dummy,
|
||||
# "Buy_Log": s3m4,
|
||||
# "Sell_Log": s4_dummy,
|
||||
# "Trans": s5_dummy,
|
||||
# "P_Ext_Markets": s6_dummy
|
||||
# }
|
||||
# },
|
||||
# "m3": {
|
||||
# "behaviors": {
|
||||
# "b1": b1m3,
|
||||
# "b2": b2m3
|
||||
# },
|
||||
# "states": {
|
||||
# "Z": s1m3,
|
||||
# "Price": s2m3,
|
||||
# }
|
||||
# }
|
||||
#treat environmental processes as a mechanism
|
||||
"ep": {
|
||||
"behaviors": {
|
||||
"dummy": dummy_behavior
|
||||
},
|
||||
"states": {
|
||||
"Z": s1_dummy,
|
||||
"Price": s2_dummy,
|
||||
"Buy_Log": s3_dummy,
|
||||
"Sell_Log": s4_dummy,
|
||||
"Trans": s5_dummy,
|
||||
"P_Ext_Markets": es4p2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sim_config = {
|
||||
"N": 1,
|
||||
"T": range(1000)
|
||||
}
|
||||
|
||||
configs.append(Configuration(sim_config, state_dict, seed, exogenous_states, env_processes, mechanisms))
|
||||
|
|
@ -1,443 +0,0 @@
|
|||
from decimal import Decimal
|
||||
import numpy as np
|
||||
|
||||
from SimCAD import Configuration, configs
|
||||
from SimCAD.configuration import exo_update_per_ts, bound_norm_random, \
|
||||
ep_time_step
|
||||
|
||||
# behavior_ops = []
|
||||
# behavior_ops = [foldr(dict_elemwise_sum())]
|
||||
|
||||
seed = {
|
||||
'z': np.random.RandomState(1)
|
||||
# 'a': np.random.RandomState(2),
|
||||
# 'b': np.random.RandomState(3),
|
||||
# 'c': np.random.RandomState(3)
|
||||
}
|
||||
|
||||
#Signals
|
||||
# Pr_signal
|
||||
#if s['P_Ext_Markets'] != 0:
|
||||
#Pr_signal = s['Z']/s['P_Ext_Markets']
|
||||
#else Pr_signal = 0
|
||||
# if Pr_signal < s['Z']/s['Buy_Log']:
|
||||
beta = Decimal('0.25') #agent response gain
|
||||
beta_LT = Decimal('0.1') #LT agent response gain
|
||||
alpha = Decimal('0.091') #21 day EMA forgetfullness between 0 and 1, closer to 1 discounts older obs quicker, should be 2/(N+1)
|
||||
max_withdraw_factor = Decimal('0.9')
|
||||
external_draw = Decimal('0.01') # between 0 and 1 to draw Buy_Log to external
|
||||
|
||||
# Stochastic process factors
|
||||
correction_factor = Decimal('0.01')
|
||||
volatility = Decimal('5.0')
|
||||
|
||||
|
||||
# Buy_Log_signal =
|
||||
# Z_signal =
|
||||
# Price_signal =
|
||||
# TDR_draw_signal =
|
||||
# P_Ext_Markets_signal =
|
||||
|
||||
# Behaviors per Mechanism
|
||||
|
||||
# BEHAVIOR 1: EMH Trader
|
||||
EMH_portion = Decimal('0.250')
|
||||
EMH_Ext_Hold = Decimal('42000.0')
|
||||
|
||||
def b1m1(step, sL, s):
|
||||
print('b1m1')
|
||||
# y = 'P_Ext_Markets'
|
||||
# Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# if Psignal_ext < Psignal_int:
|
||||
# return beta*(Psignal_int - Psignal_ext) * s['Z'] # Deposited amount in TDR
|
||||
# else:
|
||||
# return 0 # Decimal(0.000001)
|
||||
# return (y,x)
|
||||
theta = (s['Z']*EMH_portion*s['Price'])/(s['Z']*EMH_portion*s['Price'] + EMH_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
buy = beta * theta*EMH_Ext_Hold * s['P_Ext_Markets']/(s['Price']*EMH_portion*(1-theta))
|
||||
return {'buy_order1': buy}
|
||||
elif s['Price'] > (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return {'buy_order1': 0}
|
||||
else:
|
||||
return {'buy_order1': 0}
|
||||
|
||||
def b1m2(step, sL, s):
|
||||
print('b1m2')
|
||||
theta = (s['Z']*EMH_portion*s['Price'])/(s['Z']*EMH_portion*s['Price'] + EMH_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
return {'sell_order1': 0}
|
||||
elif s['Price'] > (theta*EMH_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*EMH_portion*(1-theta)):
|
||||
sell = beta * theta*EMH_Ext_Hold * s['P_Ext_Markets']/(s['Price']*EMH_portion*(1-theta))
|
||||
return {'sell_order1': sell}
|
||||
else:
|
||||
return {'sell_order1': 0}
|
||||
|
||||
# BEHAVIOR 3: Herding
|
||||
|
||||
|
||||
# BEHAVIOR 4: HODLers
|
||||
HODL_belief = Decimal('10.0')
|
||||
HODL_portion = Decimal('0.250')
|
||||
HODL_Ext_Hold = Decimal('4200.0')
|
||||
|
||||
def b4m2(step, sL, s):
|
||||
print('b4m2')
|
||||
theta = (s['Z']*HODL_portion*s['Price'])/(s['Z']*HODL_portion*s['Price'] + HODL_Ext_Hold * s['P_Ext_Markets'])
|
||||
if s['Price'] < 1/HODL_belief*(theta*HODL_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*HODL_portion*(1-theta)):
|
||||
sell = beta * theta*HODL_Ext_Hold * s['P_Ext_Markets']/(s['Price']*HODL_portion*(1-theta))
|
||||
return {'sell_order2': sell}
|
||||
elif s['Price'] > (theta*HODL_Ext_Hold * s['P_Ext_Markets'])/(s['Z']*HODL_portion*(1-theta)):
|
||||
return {'sell_order2': 0}
|
||||
else:
|
||||
return {'sell_order2': 0}
|
||||
|
||||
|
||||
# BEHAVIOR 2: Withdraw TDR and burn Zeus
|
||||
# Selling Agent- Arbitrage on TDR ext v TDR int signals
|
||||
# def b2m1(step, sL, s):
|
||||
# Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# if Psignal_ext > Psignal_int:
|
||||
# # withdrawn amount in TDR, subject to TDR limit
|
||||
# return - np.minimum(beta*(Psignal_ext - Psignal_int) * s['Z'],s['Buy_Log']*max_withdraw_factor)
|
||||
# else:
|
||||
# return 0 #- Decimal(0.000001)
|
||||
# return 0
|
||||
|
||||
# BEHAVIOR 1: Deposit TDR and mint Zeus
|
||||
# Buying Agent- Arbitrage on Price and Z signals
|
||||
# def b1m2(step, sL, s):
|
||||
# # Psignal_ext = s['P_Ext_Markets'] / s['Z']
|
||||
# # Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# # if Psignal_ext > Psignal_int:
|
||||
# # # withdrawn amount in TDR, subject to TDR limit
|
||||
# # return - np.minimum(beta*(Psignal_ext - Psignal_int) * s['Z'],s['Buy_Log']*max_withdraw_factor)
|
||||
# # else:
|
||||
# # return 0 #- Decimal(0.000001)
|
||||
# #
|
||||
# # LT more valuable than ST = deposit TDR and mint Z
|
||||
# Psignal_LT = s['Price'] / s['Z']
|
||||
# if Psignal_LT > 1:
|
||||
# return beta_LT*(Psignal_LT - 1) * s['Z']
|
||||
# else:
|
||||
# return 0
|
||||
|
||||
# Behavior will go here- b2m2, putting in mech 3: b1m3 for debugging
|
||||
# def b2m2(step, sL, s):
|
||||
# # Psignal_LT = s['Price'] / s['Z']
|
||||
# # if Psignal_LT > 1:
|
||||
# test = np.arange(1,10)
|
||||
# return test
|
||||
|
||||
# Selling Agent- Arbitrage on Price and Z signals
|
||||
# def b1m3(step, sL, s):
|
||||
# Psignal_LT = s['Price'] / s['Z']
|
||||
# if Psignal_LT < 1:
|
||||
# return - np.minimum(beta_LT*(Psignal_LT - 1) * s['Z'], s['Z']*max_withdraw_factor)
|
||||
# else:
|
||||
# return 0
|
||||
|
||||
|
||||
# def b2m3(step, sL, s):
|
||||
# return 0
|
||||
|
||||
# Internal States per Mechanism
|
||||
# Deposit TDR/Mint Zeus
|
||||
# def s1m1(step, sL, s, _input):
|
||||
# s['Z'] = s['Z'] + _input
|
||||
|
||||
|
||||
# STATES
|
||||
|
||||
# ZEUS Fixed Supply
|
||||
def s1m1(step, sL, s, _input):
|
||||
y = 'Z'
|
||||
x = s['Z'] #+ _input # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
def s2m1(step, sL, s, _input):
|
||||
y = 'Price'
|
||||
x = (s['P_Ext_Markets'] - _input['buy_order1']) /s['Z'] *10000
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
def s3m1(step, sL, s, _input):
|
||||
y = 'Buy_Log'
|
||||
x = _input['buy_order1'] # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
def s4m2(step, sL, s, _input):
|
||||
y = 'Sell_Log'
|
||||
x = _input['sell_order1'] + _input['sell_order2'] # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
def s3m3(step, sL, s, _input):
|
||||
y = 'Buy_Log'
|
||||
x = s['Buy_Log'] + _input # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
# Price Update
|
||||
def s2m3(step, sL, s, _input):
|
||||
|
||||
y = 'Price'
|
||||
#var1 = Decimal.from_float(s['Buy_Log'])
|
||||
x = s['Price'] + s['Buy_Log'] * 1/s['Z'] - s['Sell_Log']/s['Z']
|
||||
#+ np.divide(s['Buy_Log'],s['Z']) - np.divide() # / Psignal_int
|
||||
return (y, x)
|
||||
|
||||
|
||||
|
||||
def s6m1(step, sL, s, _input):
|
||||
y = 'P_Ext_Markets'
|
||||
x = s['P_Ext_Markets'] - _input
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
def s2m2(step, sL, s, _input):
|
||||
y = 'Price'
|
||||
x = (s['P_Ext_Markets'] - _input) /s['Z'] *10000
|
||||
#x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
return (y, x)
|
||||
|
||||
# def s1m1(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] + _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m1(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m1(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] + _input # Input already in TDR * s['Z']
|
||||
# return (y, x)
|
||||
|
||||
# # Withdraw TDR/Burn Zeus
|
||||
# def s1m2(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] #+ _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m2(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m2(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] + _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s1m3(step, sL, s, _input):
|
||||
# Psignal_int = s['Buy_Log'] / s['Z']
|
||||
# y = 'Z'
|
||||
# x = s['Z'] #+ _input / Psignal_int
|
||||
# return (y, x)
|
||||
|
||||
# def s2m3(step, sL, s, _input):
|
||||
# y = 'Price'
|
||||
# x= alpha * s['Z'] + (1 - alpha)*s['Price']
|
||||
# return (y, x)
|
||||
|
||||
# def s3m3(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log'] #+ _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s3m4(step, sL, s, _input):
|
||||
# y = 'Buy_Log'
|
||||
# x = s['Buy_Log']*(1-external_draw) + s['Sell_Log']*external_draw # _input #* s['Z']
|
||||
# # y = 'Buy_Log'
|
||||
# # x = s['Buy_Log'] + _input
|
||||
# return (y, x)
|
||||
|
||||
# def s1m3(step, sL, s, _input):
|
||||
# s['Z'] = s['Z'] + _input
|
||||
# def s2m3(step, sL, s, _input):
|
||||
# s['Price'] = s['Price'] + _input
|
||||
|
||||
# Exogenous States
|
||||
proc_one_coef_A = -125
|
||||
proc_one_coef_B = 125
|
||||
# def es3p1(step, sL, s, _input):
|
||||
# s['s3'] = s['s3'] * bound_norm_random(seed['a'], proc_one_coef_A, proc_one_coef_B)
|
||||
# def es4p2(step, sL, s, _input):
|
||||
# s['P_Ext_Markets'] = s['P_Ext_Markets'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B)
|
||||
# def es5p2(step, sL, s, _input): # accept timedelta instead of timedelta params
|
||||
# s['timestamp'] = ep_time_step(s, s['timestamp'], seconds=1)
|
||||
def es3p1(step, sL, s, _input):
|
||||
y = 's3'
|
||||
x = s['s3'] + 1
|
||||
return (y, x)
|
||||
# def es4p2(step, sL, s, _input):
|
||||
# y = 'P_Ext_Markets'
|
||||
# # bound_norm_random defined in utils.py
|
||||
|
||||
# #x = s['P_Ext_Markets'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B)
|
||||
# expected_change = correction_factor*(s['P_Ext_Markets']-s['Buy_Log'])
|
||||
# vol = np.random.randint(1,volatility)
|
||||
# change = expected_change * vol
|
||||
# # change_float = (np.random.normal(expected_change,volatility*expected_change) #Decimal('1.0')
|
||||
# #change = Decimal.from_float(change_float)
|
||||
# x = s['P_Ext_Markets'] + change
|
||||
|
||||
# return (y, x)
|
||||
|
||||
# A change in belief of actual price, passed onto behaviors to make action
|
||||
def es4p2(step, sL, s, _input):
|
||||
y = 'P_Ext_Markets'
|
||||
x = s['P_Ext_Markets'] + bound_norm_random(seed['z'], proc_one_coef_A, proc_one_coef_B)
|
||||
|
||||
return (y,x)
|
||||
|
||||
|
||||
def es5p2(step, sL, s, _input): # accept timedelta instead of timedelta params
|
||||
y = 'timestamp'
|
||||
x = ep_time_step(s, s['timestamp'], seconds=1)
|
||||
return (y, x)
|
||||
#Environment States
|
||||
# def stochastic(reference, seed, correction = 0.01):
|
||||
# series = np.zeros(len(reference))
|
||||
# series[0] = reference[0]
|
||||
# for i in range(1,len(reference)):
|
||||
# expected_change = correction*(reference[i]-series[i-1])
|
||||
# normalized_expected_change = np.abs(expected_change)*(reference[i])/(reference[i-1])
|
||||
# seed_int = seed.randint(1,10)
|
||||
# change = np.random.normal(expected_change,seed_int*normalized_expected_change)
|
||||
|
||||
# series[i] = series[i-1]+change
|
||||
# # avoid negative series returns
|
||||
# if series[i] <= 0:
|
||||
# series[i] = .01
|
||||
# #series[i] = series[i-1]+change
|
||||
|
||||
# return [series,seed_int]
|
||||
# ref3 = np.arange(1,1000)*.1
|
||||
# test = stochastic(ref3,seed['b'])
|
||||
|
||||
# def env_a(ref3,seed['b']):
|
||||
# return stochastic(ref3,seed['b'])
|
||||
def env_a(x):
|
||||
return 100
|
||||
def env_b(x):
|
||||
return 21000000
|
||||
# def what_ever(x):
|
||||
# return x + 1
|
||||
|
||||
# Genesis States
|
||||
state_dict = {
|
||||
'Z': Decimal(21000000.0),
|
||||
'Price': Decimal(100.0), # Initialize = Z for EMA
|
||||
'Buy_Log': Decimal(0.0),
|
||||
'Sell_Log': Decimal(0.0),
|
||||
'Trans': Decimal(0.0),
|
||||
'P_Ext_Markets': Decimal(25000.0),
|
||||
|
||||
# 's2': Decimal(0.0),
|
||||
# 's3': Decimal(0.0),
|
||||
# 's4': Decimal(0.0),
|
||||
'timestamp': '2018-10-01 15:16:24'
|
||||
}
|
||||
|
||||
# exogenous_states = {
|
||||
# # "s3": es3p1,
|
||||
# "P_Ext_Markets": es4p2,
|
||||
# "timestamp": es5p2
|
||||
# }
|
||||
|
||||
exogenous_states = exo_update_per_ts(
|
||||
{
|
||||
# "s3": es3p1,
|
||||
"P_Ext_Markets": es4p2,
|
||||
"timestamp": es5p2
|
||||
}
|
||||
)
|
||||
|
||||
env_processes = {
|
||||
# "s3": env_proc('2018-10-01 15:16:25', env_a),
|
||||
# "P_Ext_Markets": env_proc('2018-10-01 15:16:25', env_b)
|
||||
}
|
||||
|
||||
# test return vs. non-return functions as lambdas
|
||||
# test fully defined functions
|
||||
mechanisms = {
|
||||
"m1": {
|
||||
"behaviors": {
|
||||
"b1": b1m1, # lambda step, sL, s: s['s1'] + 1,
|
||||
# "b2": b2m1
|
||||
},
|
||||
"states": {
|
||||
"Z": s1m1,
|
||||
# "Price": s2_dummy,
|
||||
"Buy_Log": s3m1,
|
||||
}
|
||||
},
|
||||
"m2": {
|
||||
"behaviors": {
|
||||
"b1": b1m2,
|
||||
"b4": b4m2
|
||||
},
|
||||
"states": {
|
||||
"Sell_Log":s4m2,
|
||||
}
|
||||
},
|
||||
"m3": {
|
||||
"behaviors": {
|
||||
},
|
||||
"states": {
|
||||
"Price": s2m3,
|
||||
}
|
||||
},
|
||||
# "m3": {
|
||||
# "behaviors": {
|
||||
# "b1": b1m3,
|
||||
# "b2": b2m3
|
||||
# },
|
||||
# "states": {
|
||||
# "Z": s1m3,
|
||||
# "Price": s2m3,
|
||||
# "Buy_Log": s3m3,
|
||||
# }
|
||||
# },
|
||||
# "m4": {
|
||||
# "behaviors": {
|
||||
# },
|
||||
# "states": {
|
||||
# }
|
||||
# },
|
||||
# "m3": {
|
||||
# "behaviors": {
|
||||
# "b1": b1m3,
|
||||
# "b2": b2m3
|
||||
# },
|
||||
# "states": {
|
||||
# "Z": s1m3,
|
||||
# "Price": s2m3,
|
||||
# }
|
||||
# }
|
||||
#treat environmental processes as a mechanism
|
||||
"ep": {
|
||||
"behaviors": {
|
||||
},
|
||||
"states": {
|
||||
"P_Ext_Markets": es4p2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sim_config = {
|
||||
"N": 1,
|
||||
"T": range(1000)
|
||||
}
|
||||
|
||||
configs.append(Configuration(sim_config, state_dict, seed, exogenous_states, env_processes, mechanisms))
|
||||
|
|
@ -1,16 +1,13 @@
|
|||
import pandas as pd
|
||||
from tabulate import tabulate
|
||||
|
||||
# The following imports NEED to be in the exact same order
|
||||
# The following imports NEED to be in the exact order
|
||||
from SimCAD.engine import ExecutionMode, ExecutionContext, Executor
|
||||
from simulations.validation import config1, config2
|
||||
from validation import config1, config2
|
||||
from SimCAD import configs
|
||||
|
||||
# ToDo: pass ExecutionContext with execution method as ExecutionContext input
|
||||
|
||||
exec_mode = ExecutionMode()
|
||||
|
||||
|
||||
print("Simulation Execution 1")
|
||||
print()
|
||||
first_config = [configs[0]] # from config1
|
||||
|
|
@ -18,7 +15,6 @@ single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
|
|||
run1 = Executor(exec_context=single_proc_ctx, configs=first_config)
|
||||
run1_raw_result, tensor_field = run1.main()
|
||||
result = pd.DataFrame(run1_raw_result)
|
||||
# result.to_csv('~/Projects/DiffyQ-SimCAD/results/config.csv', sep=',')
|
||||
print()
|
||||
print("Tensor Field:")
|
||||
print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
|
||||
|
|
@ -37,4 +33,4 @@ for raw_result, tensor_field in run2.main():
|
|||
print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
|
||||
print("Output:")
|
||||
print(tabulate(result, headers='keys', tablefmt='psql'))
|
||||
print()
|
||||
print()
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -7,6 +7,7 @@ from SimCAD.configuration import Configuration
|
|||
from SimCAD.configuration.utils import exo_update_per_ts, proc_trigger, bound_norm_random, \
|
||||
ep_time_step
|
||||
|
||||
|
||||
seed = {
|
||||
'z': np.random.RandomState(1),
|
||||
'a': np.random.RandomState(2),
|
||||
|
|
@ -14,8 +15,8 @@ seed = {
|
|||
'c': np.random.RandomState(3)
|
||||
}
|
||||
|
||||
|
||||
# Behaviors per Mechanism
|
||||
# Different return types per mechanism ?? *** No ***
|
||||
def b1m1(step, sL, s):
|
||||
return {'param1': 1}
|
||||
def b2m1(step, sL, s):
|
||||
|
|
@ -31,15 +32,15 @@ def b1m3(step, sL, s):
|
|||
def b2m3(step, sL, s):
|
||||
return {'param1': ['d'], 'param2': np.array([20, 200])}
|
||||
|
||||
# deff not more than 2
|
||||
|
||||
# Internal States per Mechanism
|
||||
def s1m1(step, sL, s, _input):
|
||||
y = 's1'
|
||||
x = _input['param1'] #+ [Coef1 x 5]
|
||||
x = _input['param1']
|
||||
return (y, x)
|
||||
def s2m1(step, sL, s, _input):
|
||||
y = 's2'
|
||||
x = _input['param2'] #+ [Coef2 x 5]
|
||||
x = _input['param2']
|
||||
return (y, x)
|
||||
|
||||
def s1m2(step, sL, s, _input):
|
||||
|
|
@ -60,6 +61,7 @@ def s2m3(step, sL, s, _input):
|
|||
x = _input['param2']
|
||||
return (y, x)
|
||||
|
||||
|
||||
# Exogenous States
|
||||
proc_one_coef_A = 0.7
|
||||
proc_one_coef_B = 1.3
|
||||
|
|
@ -90,6 +92,7 @@ def env_b(x):
|
|||
# def what_ever(x):
|
||||
# return x + 1
|
||||
|
||||
|
||||
# Genesis States
|
||||
genesis_states = {
|
||||
's1': Decimal(0.0),
|
||||
|
|
@ -99,6 +102,7 @@ genesis_states = {
|
|||
'timestamp': '2018-10-01 15:16:24'
|
||||
}
|
||||
|
||||
|
||||
# remove `exo_update_per_ts` to update every ts
|
||||
exogenous_states = exo_update_per_ts(
|
||||
{
|
||||
|
|
@ -108,33 +112,20 @@ exogenous_states = exo_update_per_ts(
|
|||
}
|
||||
)
|
||||
|
||||
# ToDo: make env proc trigger field agnostic
|
||||
# ToDo: input json into function renaming __name__
|
||||
|
||||
env_processes = {
|
||||
"s3": env_a,
|
||||
"s4": proc_trigger('2018-10-01 15:16:25', env_b)
|
||||
}
|
||||
|
||||
# lambdas
|
||||
# genesis Sites should always be there
|
||||
# [1, 2]
|
||||
# behavior_ops = [ foldr(_ + _), lambda x: x + 0 ]
|
||||
|
||||
# [1, 2] = {'b1': ['a'], 'b2', [1]} =
|
||||
# behavior_ops = [ behavior_to_dict, print_fwd, sum_dict_values ]
|
||||
# behavior_ops = [foldr(dict_elemwise_sum())]
|
||||
# behavior_ops = [foldr(lambda a, b: a + b)]
|
||||
|
||||
# need at least 1 behaviour and 1 state function for the 1st mech with behaviors
|
||||
# mechanisms = {}
|
||||
|
||||
mechanisms = {
|
||||
"m1": {
|
||||
"behaviors": {
|
||||
"b1": b1m1, # lambda step, sL, s: s['s1'] + 1,
|
||||
"b1": b1m1,
|
||||
"b2": b2m1
|
||||
},
|
||||
"states": { # exclude only. TypeError: reduce() of empty sequence with no initial value
|
||||
"states": {
|
||||
"s1": s1m1,
|
||||
"s2": s2m1
|
||||
}
|
||||
|
|
@ -161,11 +152,13 @@ mechanisms = {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
sim_config = {
|
||||
"N": 2,
|
||||
"T": range(5)
|
||||
}
|
||||
|
||||
|
||||
configs.append(
|
||||
Configuration(
|
||||
sim_config=sim_config,
|
||||
|
|
@ -175,4 +168,4 @@ configs.append(
|
|||
env_processes=env_processes,
|
||||
mechanisms=mechanisms
|
||||
)
|
||||
)
|
||||
)
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ seed = {
|
|||
'c': np.random.RandomState(3)
|
||||
}
|
||||
|
||||
|
||||
# Behaviors per Mechanism
|
||||
# Different return types per mechanism ?? *** No ***
|
||||
def b1m1(step, sL, s):
|
||||
return {'param1': 1}
|
||||
def b2m1(step, sL, s):
|
||||
|
|
@ -27,7 +27,6 @@ def b1m2(step, sL, s):
|
|||
def b2m2(step, sL, s):
|
||||
return {'param1': 'b', 'param2': 4}
|
||||
|
||||
|
||||
def b1m3(step, sL, s):
|
||||
return {'param1': ['c'], 'param2': np.array([10, 100])}
|
||||
def b2m3(step, sL, s):
|
||||
|
|
@ -62,6 +61,7 @@ def s2m3(step, sL, s, _input):
|
|||
x = _input['param2']
|
||||
return (y, x)
|
||||
|
||||
|
||||
# Exogenous States
|
||||
proc_one_coef_A = 0.7
|
||||
proc_one_coef_B = 1.3
|
||||
|
|
@ -92,6 +92,7 @@ def env_b(x):
|
|||
# def what_ever(x):
|
||||
# return x + 1
|
||||
|
||||
|
||||
# Genesis States
|
||||
genesis_states = {
|
||||
's1': Decimal(0.0),
|
||||
|
|
@ -101,8 +102,8 @@ genesis_states = {
|
|||
'timestamp': '2018-10-01 15:16:24'
|
||||
}
|
||||
|
||||
|
||||
# remove `exo_update_per_ts` to update every ts
|
||||
# why `exo_update_per_ts` here instead of `env_processes`
|
||||
exogenous_states = exo_update_per_ts(
|
||||
{
|
||||
"s3": es3p1,
|
||||
|
|
@ -111,32 +112,20 @@ exogenous_states = exo_update_per_ts(
|
|||
}
|
||||
)
|
||||
|
||||
# make env proc trigger field agnostic
|
||||
|
||||
env_processes = {
|
||||
"s3": proc_trigger('2018-10-01 15:16:25', env_a),
|
||||
"s4": proc_trigger('2018-10-01 15:16:25', env_b)
|
||||
}
|
||||
|
||||
# lambdas
|
||||
# genesis Sites should always be there
|
||||
# [1, 2]
|
||||
# behavior_ops = [ foldr(_ + _), lambda x: x + 0 ]
|
||||
|
||||
|
||||
# [1, 2] = {'b1': ['a'], 'b2', [1]} =
|
||||
# behavior_ops = [behavior_to_dict, print_fwd, sum_dict_values]
|
||||
# behavior_ops = [foldr(dict_elemwise_sum())]
|
||||
# behavior_ops = []
|
||||
|
||||
# need at least 1 behaviour and 1 state function for the 1st mech with behaviors
|
||||
# mechanisms = {}
|
||||
mechanisms = {
|
||||
"m1": {
|
||||
"behaviors": {
|
||||
"b1": b1m1, # lambda step, sL, s: s['s1'] + 1,
|
||||
"b1": b1m1,
|
||||
# "b2": b2m1
|
||||
},
|
||||
"states": { # exclude only. TypeError: reduce() of empty sequence with no initial value
|
||||
"states": {
|
||||
"s1": s1m1,
|
||||
# "s2": s2m1
|
||||
}
|
||||
|
|
@ -163,11 +152,13 @@ mechanisms = {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
sim_config = {
|
||||
"N": 2,
|
||||
"T": range(5)
|
||||
}
|
||||
|
||||
|
||||
configs.append(
|
||||
Configuration(
|
||||
sim_config=sim_config,
|
||||
|
|
@ -177,4 +168,4 @@ configs.append(
|
|||
env_processes=env_processes,
|
||||
mechanisms=mechanisms
|
||||
)
|
||||
)
|
||||
)
|
||||
|
|
|
|||
Loading…
Reference in New Issue