diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/glm.ipynb b/py/glm.ipynb deleted file mode 100644 index b11d62b..0000000 --- a/py/glm.ipynb +++ /dev/null @@ -1,64 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": "GLM Playgorund\n", - "metadata": { - "pycharm": { - "metadata": false - } - } - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "3" - }, - "metadata": {}, - "output_type": "execute_result", - "execution_count": 17 - } - ], - "source": "#!conda install --yes statsmodel\na \u003d 1+2\na\n\n\nfrom statsmodels.formula.api import ols\n\nmy_data \u003d {}\n\nmodel \u003d ols(formula\u003d\"y~X\", data\u003dmy_data).fit()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - }, - "stem_cell": { - "cell_type": "raw", - "source": "", - "metadata": { - "pycharm": { - "metadata": false - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/glm.ipynb b/py/glm.ipynb deleted file mode 100644 index b11d62b..0000000 --- a/py/glm.ipynb +++ /dev/null @@ -1,64 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": "GLM Playgorund\n", - "metadata": { - "pycharm": { - "metadata": false - } - } - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "3" - }, - "metadata": {}, - "output_type": "execute_result", - "execution_count": 17 - } - ], - "source": "#!conda install --yes statsmodel\na \u003d 1+2\na\n\n\nfrom statsmodels.formula.api import ols\n\nmy_data \u003d {}\n\nmodel \u003d ols(formula\u003d\"y~X\", data\u003dmy_data).fit()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - }, - "stem_cell": { - "cell_type": "raw", - "source": "", - "metadata": { - "pycharm": { - "metadata": false - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/gym_dqn.py b/py/gym_dqn.py deleted file mode 100644 index eac09ae..0000000 --- a/py/gym_dqn.py +++ /dev/null @@ -1,41 +0,0 @@ -# %% Keras-RL for gym cart pole - -import gym -from rl.policy import EpsGreedyQPolicy, LinearAnnealedPolicy -from rl.memory import SequentialMemory -from rl.agents.dqn import DQNAgent - -# 1. model -def build_model(state_size, num_actions): - input = Input(shape=(1,state_size)) - x = Flatten()(input) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - output = Dense(num_actions, activation='linear')(x) - model = Model(inputs=input, outputs=output) - print(model.summary()) - return model - -model = build_model() - -# 2. memory -memory = SequentialMemory(limit=50000, window_length=1) - -# 3. policy (decay eps) - -policy = LinearAnnealedPolicy( - EpsGreedyQPolicy(), - attr='eps', - value_max=1., - value_min=.1, - value_test=.05, - nb_steps=10000) - -# 4. agent - -dqn = DQNAgent( - model=model, nb_actions=num_actions, memory=memory, nb_steps_warmup=10, - target_model_update=1e-2, policy=policy) - -dqn.compile(Adam(lr=1e-3), metrics=['mae']) \ No newline at end of file diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/glm.ipynb b/py/glm.ipynb deleted file mode 100644 index b11d62b..0000000 --- a/py/glm.ipynb +++ /dev/null @@ -1,64 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": "GLM Playgorund\n", - "metadata": { - "pycharm": { - "metadata": false - } - } - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "3" - }, - "metadata": {}, - "output_type": "execute_result", - "execution_count": 17 - } - ], - "source": "#!conda install --yes statsmodel\na \u003d 1+2\na\n\n\nfrom statsmodels.formula.api import ols\n\nmy_data \u003d {}\n\nmodel \u003d ols(formula\u003d\"y~X\", data\u003dmy_data).fit()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - }, - "stem_cell": { - "cell_type": "raw", - "source": "", - "metadata": { - "pycharm": { - "metadata": false - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/gym_dqn.py b/py/gym_dqn.py deleted file mode 100644 index eac09ae..0000000 --- a/py/gym_dqn.py +++ /dev/null @@ -1,41 +0,0 @@ -# %% Keras-RL for gym cart pole - -import gym -from rl.policy import EpsGreedyQPolicy, LinearAnnealedPolicy -from rl.memory import SequentialMemory -from rl.agents.dqn import DQNAgent - -# 1. model -def build_model(state_size, num_actions): - input = Input(shape=(1,state_size)) - x = Flatten()(input) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - output = Dense(num_actions, activation='linear')(x) - model = Model(inputs=input, outputs=output) - print(model.summary()) - return model - -model = build_model() - -# 2. memory -memory = SequentialMemory(limit=50000, window_length=1) - -# 3. policy (decay eps) - -policy = LinearAnnealedPolicy( - EpsGreedyQPolicy(), - attr='eps', - value_max=1., - value_min=.1, - value_test=.05, - nb_steps=10000) - -# 4. agent - -dqn = DQNAgent( - model=model, nb_actions=num_actions, memory=memory, nb_steps_warmup=10, - target_model_update=1e-2, policy=policy) - -dqn.compile(Adam(lr=1e-3), metrics=['mae']) \ No newline at end of file diff --git a/py/nilearn_playground.ipynb b/py/nilearn_playground.ipynb deleted file mode 100644 index e05f854..0000000 --- a/py/nilearn_playground.ipynb +++ /dev/null @@ -1,207 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/morteza/miniconda3/lib/python3.7/site-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n", - " warnings.warn(msg, category=DeprecationWarning)\n" - ] - } - ], - "source": [ - "from nilearn import plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_glass_brain(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from nilearn import image, plotting\n", - "img = image.load_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")\n", - "img = image.smooth_img(img, fwhm=4)\n", - "plotting.plot_img(img)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nilearn datasets: ['/Users/morteza/nilearn_data']\n", - "\n", - "Dataset created in /Users/morteza/nilearn_data/nyu_rest\n", - "\n", - "Downloading data from http://www.nitrc.org/frs/download.php/1071/NYU_TRT_session1a.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 697388519 of 697388519 bytes (100.0%, 0.0s remaining) ...done. (354 seconds, 5 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1a.tar.gz..... done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading data from http://www.nitrc.org/frs/download.php/1072/NYU_TRT_session1b.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 653093650 of 653093650 bytes (100.0%, 0.0s remaining) ...done. (273 seconds, 4 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1b.tar.gz..... done.\n" - ] - }, - { - "ename": "AttributeError", - "evalue": "images", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'images'", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"nilearn datasets: {datasets.get_data_dirs()}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch_nyu_rest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_stat_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_glass_brain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 107\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setstate__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: images" - ] - } - ], - "source": [ - "from nilearn import datasets, plotting\n", - "print(f\"nilearn datasets: {datasets.get_data_dirs()}\")\n", - "dataset = datasets.fetch_nyu_rest()\n", - "plotting.plot_stat_map(dataset.images[0])\n", - "plotting.plot_glass_brain(dataset.images[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/glm.ipynb b/py/glm.ipynb deleted file mode 100644 index b11d62b..0000000 --- a/py/glm.ipynb +++ /dev/null @@ -1,64 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": "GLM Playgorund\n", - "metadata": { - "pycharm": { - "metadata": false - } - } - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "3" - }, - "metadata": {}, - "output_type": "execute_result", - "execution_count": 17 - } - ], - "source": "#!conda install --yes statsmodel\na \u003d 1+2\na\n\n\nfrom statsmodels.formula.api import ols\n\nmy_data \u003d {}\n\nmodel \u003d ols(formula\u003d\"y~X\", data\u003dmy_data).fit()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - }, - "stem_cell": { - "cell_type": "raw", - "source": "", - "metadata": { - "pycharm": { - "metadata": false - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/gym_dqn.py b/py/gym_dqn.py deleted file mode 100644 index eac09ae..0000000 --- a/py/gym_dqn.py +++ /dev/null @@ -1,41 +0,0 @@ -# %% Keras-RL for gym cart pole - -import gym -from rl.policy import EpsGreedyQPolicy, LinearAnnealedPolicy -from rl.memory import SequentialMemory -from rl.agents.dqn import DQNAgent - -# 1. model -def build_model(state_size, num_actions): - input = Input(shape=(1,state_size)) - x = Flatten()(input) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - output = Dense(num_actions, activation='linear')(x) - model = Model(inputs=input, outputs=output) - print(model.summary()) - return model - -model = build_model() - -# 2. memory -memory = SequentialMemory(limit=50000, window_length=1) - -# 3. policy (decay eps) - -policy = LinearAnnealedPolicy( - EpsGreedyQPolicy(), - attr='eps', - value_max=1., - value_min=.1, - value_test=.05, - nb_steps=10000) - -# 4. agent - -dqn = DQNAgent( - model=model, nb_actions=num_actions, memory=memory, nb_steps_warmup=10, - target_model_update=1e-2, policy=policy) - -dqn.compile(Adam(lr=1e-3), metrics=['mae']) \ No newline at end of file diff --git a/py/nilearn_playground.ipynb b/py/nilearn_playground.ipynb deleted file mode 100644 index e05f854..0000000 --- a/py/nilearn_playground.ipynb +++ /dev/null @@ -1,207 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/morteza/miniconda3/lib/python3.7/site-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n", - " warnings.warn(msg, category=DeprecationWarning)\n" - ] - } - ], - "source": [ - "from nilearn import plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_glass_brain(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from nilearn import image, plotting\n", - "img = image.load_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")\n", - "img = image.smooth_img(img, fwhm=4)\n", - "plotting.plot_img(img)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nilearn datasets: ['/Users/morteza/nilearn_data']\n", - "\n", - "Dataset created in /Users/morteza/nilearn_data/nyu_rest\n", - "\n", - "Downloading data from http://www.nitrc.org/frs/download.php/1071/NYU_TRT_session1a.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 697388519 of 697388519 bytes (100.0%, 0.0s remaining) ...done. (354 seconds, 5 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1a.tar.gz..... done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading data from http://www.nitrc.org/frs/download.php/1072/NYU_TRT_session1b.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 653093650 of 653093650 bytes (100.0%, 0.0s remaining) ...done. (273 seconds, 4 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1b.tar.gz..... done.\n" - ] - }, - { - "ename": "AttributeError", - "evalue": "images", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'images'", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"nilearn datasets: {datasets.get_data_dirs()}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch_nyu_rest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_stat_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_glass_brain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 107\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setstate__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: images" - ] - } - ], - "source": [ - "from nilearn import datasets, plotting\n", - "print(f\"nilearn datasets: {datasets.get_data_dirs()}\")\n", - "dataset = datasets.fetch_nyu_rest()\n", - "plotting.plot_stat_map(dataset.images[0])\n", - "plotting.plot_glass_brain(dataset.images[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/py/pandas.ipynb b/py/pandas.ipynb deleted file mode 100644 index b003ea9..0000000 --- a/py/pandas.ipynb +++ /dev/null @@ -1,135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false, - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['head', 'tail', 'head', 'head', 'head', 'head', 'head', 'tail', 'tail', 'head']\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "np.random.seed(123)\n", - "coins = []\n", - "coins_random_walk = [0]\n", - "for i in range(10):\n", - " if np.random.randint(0,2) == 0:\n", - " coins_random_walk.append(0)\n", - " coins.append(\"head\")\n", - " else:\n", - " coins.append(\"tail\")\n", - "print(coins)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "A = [1,2,3]\n", - "B = A + [4,5]\n", - "B.append(6)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false, - "pycharm": { - "is_executing": false, - "name": "#%% \n" - } - }, - "outputs": [ - { - "data": { - "image/png": [ - "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\n" - ], - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# matplotlib\n", - "import matplotlib.pyplot as plt\n", - "plt.scatter([1,2,3], [7,8,9], s=[3,60,90], c=['red','blue','green'], alpha=0.5)\n", - "\n", - "plt.text(10, 8.5, \"Here is some\")\n", - "\n", - "plt.grid(True)\n", - "\n", - "plt.xscale('log') \n", - "plt.xlabel(\"X Label\")\n", - "plt.ylabel(\"Y Label\")\n", - "plt.title(\"Title\")\n", - "plt.xticks([10,20,30], [\"10x\", \"20x\",\"30x\"])\n", - "plt.show()" - ] - } - ], - "metadata": { - "authors": [ - { - "name": "Morteza Ansarinia" - } - ], - "description": "Some random codes to learn/train/remember pandas :-)\n", - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - }, - "pycharm": { - "stem_cell": { - "cell_type": "raw", - "metadata": { - "collapsed": false - }, - "source": [ - "Simulate \n" - ] - } - }, - "tags": [ - "pandas", - "playground" - ], - "title": "Pandas Playground" - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/behaverse/timeline_editor/digitspan_block.py b/behaverse/timeline_editor/digitspan_block.py new file mode 100644 index 0000000..07fca4a --- /dev/null +++ b/behaverse/timeline_editor/digitspan_block.py @@ -0,0 +1,89 @@ +import streamlit as st +import json +from enum import Enum + +config_json = { + "Timelines": {}, + "Blocks": {} +} + + +class HudWidgetPosition(Enum): + Hidden = "Hidden" + StatusBarLeft = "Status bar (left)" + StatusBarCenter = "Status bar (center)" + StatusBarRight = "Status bar (right)" + InformationPanel = "Information panel" + + +class EnumProgressElementStyle(Enum): + Continuous = "Continuous" + # ... + + +class ShowAccuracyCheckFeedback(Enum): + Always = "Always" + Never = "Never" + + +class ShowCorrectTrialResponseFeedback(Enum): + Always = "Always" + OnError = "Only on error" + Never = "Never" + + +class StimulusType(Enum): + Digits = "Digits" + LowerCaseLetters = "Lowercase letters" + UpperCaseLetters = "Uppercase letters" + Symbols = "Symbols" + + +class DigitSpanBlock: + """ + UI to generate timeline config file for digit span. + """ + + def render(self): + st.title("DigitSpan - Block Generator") + # st.help(DigitSpanBlock) + + self.Name = st.sidebar.text_input('Block Name') + + st.sidebar.header("Stimulus") + self.StimulusType = self.render_enum("Stimulus Type", StimulusType) + self.StimulusPackSize = st.sidebar.number_input("Stimulus pack size", min_value=1, max_value=1) + self.SequenceLength = st.sidebar.number_input("Sequence Length", min_value=1) + + st.sidebar.header("Timing") + self.StimulusDisplayDuration = st.sidebar.number_input("Stimulus Display Duration") + self.InterstimulusInterval = st.sidebar.number_input("Interstimulus Interval (sec)", min_value=0) + self.RetentionDelay = st.sidebar.number_input("Retention Delay (sec)", min_value=0) + self.MaxIdleTime = st.sidebar.number_input("Max idle time (sec)", + min_value=self.StimulusDisplayDuration + self.InterstimulusInterval) + + st.sidebar.header("UI") + self.BlockCounterPosition = self.render_enum("Block Counter", HudWidgetPosition) + self.ShowAccuracyCheckFeedback = self.render_enum("Show accuracy feedback", ShowAccuracyCheckFeedback) + self.ShowCorrectTrialResponseFeedback = self.render_enum("Show correct response", + ShowCorrectTrialResponseFeedback) + + # show output in json format + __json = {} + __json.update(vars(self)) + del __json['Name'] + config_json["Blocks"] = {self.Name: __json} + st.json(config_json) + + @staticmethod + def render_enum(text, cls): + options = list(map(lambda e: e.name, cls)) + widget = st.sidebar.selectbox( + text, + options, + format_func=lambda k: cls[k].value) + return widget + + +if __name__ == "__main__": + DigitSpanBlock().render() diff --git a/coords2labels.py b/coords2labels.py deleted file mode 100644 index 4a05277..0000000 --- a/coords2labels.py +++ /dev/null @@ -1,44 +0,0 @@ -# %% -# A basic funtion to convert MNI coords to harvard oxford labels using spherical masking -# input: -# - list of coords of size N*3 -# output: -# - list of labels of size N - - -import numpy as np -from nilearn import datasets -from nilearn.input_data import NiftiSpheresMasker - - - -def coords2labels(coords: np.array, sphere_radius=2): - """ - - Args: - ----- - coords: 2d numpy array of size (N,3). - - Returns: - ----- - a list strings of size N. - """ - - atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') - - masker = NiftiSpheresMasker(seeds=coords,radius=sphere_radius,allow_overlap=True) - - masker.fit() - label_indices = masker.transform_single_imgs(atlas.maps).astype(int) - - labels = np.array(atlas.labels)[label_indices.flatten()].tolist() - return labels - - -# example use case: -sample_coords = [[0,0,35], - [4,5,6], - [-12, 20, -20] - ] - -coords2labels(sample_coords) \ No newline at end of file diff --git a/efo/20191223_pubmed.py b/efo/20191223_pubmed.py new file mode 100644 index 0000000..3abc17d --- /dev/null +++ b/efo/20191223_pubmed.py @@ -0,0 +1,117 @@ +#%% temp (REMOVE this, this snippet sets an env var. That's it!) +import os +os.environ['NCBI_API_KEY'] = '' + +#%% direct eutils xml requests with history support +#Note: pip install xmltodict +import os +from datetime import date +import requests +import xmltodict + +base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' +ts = date.today().strftime('%Y%m%d') + + +terms = ['Digit Span', 'Working Memory'] +db = 'pubmed' # or 'pmc' + + +def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): + """Search for a term and store all abstract in a file + """ + search_query = f'({term}[TIAB])' + url = f'{base}esearch.fcgi' + params = { + 'term': search_query.replace(' ','+'), + 'usehistory': 'y', + 'db': db, + 'retmax': 0, + 'reldate': 10 * 365, + 'api_key': api_key + } + + response = requests.get(url,params=params) + search_response = xmltodict.parse(response.text) + + #DEBUG print(search_response) + + _num_of_results = search_response['eSearchResult']['Count'] + + print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') + + + # --- FETCH ABSRACTS + url = f'{base}efetch.fcgi' + params = { + 'db': db, + 'api_key': api_key, + 'WebEnv': search_response['eSearchResult']['WebEnv'], + 'query_key': search_response['eSearchResult']['QueryKey'], + 'rettype': 'abstract', + 'retmode': 'xml' + } + + response = requests.post(url, params) + + with open(f'{output_file}', 'w') as f: + f.write(response.text) + + print(f'Succesfully stored results to {output_file}') + + return None + + + +for term in terms: + print(f'searching NCBI for: {term}...') + search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') + + +#%% [markdown] +# DEPRECATED: POST ids to history server +# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. + +#%% POST + +url = f"{base}epost.fcgi" + +params = { + 'db': db, + 'id': ','.join(map(str, [11237011,12466850])), + 'api_key': os.environ['NCBI_API_KEY'] +} + +response = requests.post(url, params) + +history_params = xmltodict.parse(response.text) + +#%% [markdown] +# ## DEPRECATED: metapub +# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. + +# Note: metapub requires an env variable named `NCBI_API_KEY`. + +#%% metapub + +import os +from metapub import PubMedFetcher + +terms = ['N-Back', 'Working Memory'] + +fetcher = PubMedFetcher() + +for term in terms: + abstracts = [] + + ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) + print(f'fetching articles for {term}') + + for index, id in enumerate(ids[:10]): + print(f'{index} of {len(ids)}...') + article = fetcher.article_by_pmid(id) + if article.abstract is not None: + abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) + + with open(f'data/{db}/{term}.txt','w') as f: + f.write('\n\n'.join(abstracts)) diff --git a/efo/20200116_efo_analysis.py b/efo/20200116_efo_analysis.py new file mode 100644 index 0000000..348e7b1 --- /dev/null +++ b/efo/20200116_efo_analysis.py @@ -0,0 +1,163 @@ +#%% [markdown] + +# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` + +#%% +#!pip install pymc3 pandas matplotlib numpy seaborn arviz + +import matplotlib.pyplot as plt + +import pandas as pd +import numpy as np + +import pandas as pd +import pymc3 as pm +import numpy as np + +from IPython.display import display +import seaborn as sns + +from scipy.stats import zscore + +sns.set_style('ticks') +az.style.use("arviz-darkgrid") + +#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' +csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' + +df = pd.read_csv(csv_path) + +no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] +tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() +constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() + +print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") +print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") + + +# change task and concepts to categories +df['context'] = df['context'].astype('category') +df['construct'] = df['construct'].astype('category') +df['task'] = df['task'].astype('category') + +#DEBUG make it one observation per task! it this necessary? +#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) + +df = df[~((df.task_hits ==0) | (df.construct_hits==0))] + +context_idx = df.context.cat.codes.values +n_context = df.context.cat.categories.size + +construct_idx = df.construct.cat.codes.values +n_constructs = df.construct.cat.categories.size + +task_idx = df.task.cat.codes.values +n_tasks = df.task.cat.categories.size + +n_obs = len(df) + +df['hits_zscore'] = zscore(df.hits) +df['task_hits_zscore'] = zscore(df.task_hits) +df['task_construct_zscore'] = zscore(df.construct_hits) + +#%% +# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution + + +with pm.Model() as model1: + # prior on mean value + mu = pm.Normal('mu', sigma=100) + + # likelihood + hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) + + display(pm.model_to_graphviz(model1)) + display(model1.check_test_point()) + + model1_trace = pm.sample(1000, model=model1) + +# plot traceplot +az.plot_trace(model1_trace) + +#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. +# ----------------------------------------------- + +sd_contexts = df.groupby('context').std().hits_zscore +hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! + +with pm.Model() as model2: + + # prior on `nu`, a parameter of final StudentT likelihood + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one + 1) + + # context parameters + context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) + context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) + + # difference between the avergae hits in EF and nonEF + ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) + + # likelihood + hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) + + display(pm.model_to_graphviz(model2)) + display(model2.check_test_point()) + model2_trace = pm.sample(model=model2) + + # plots + pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) + pm.plot_posterior(model2_trace, + var_names=['context_mu','context_sigma','EF - nonEF','nu'], + point_estimate='mode', + credible_interval=0.95, + ref_val=0) + +#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters +# ----------------------------------------------- +ef_df = df[df.context=='EF'] +ef_construct_mean = ef_df.groupby('construct').mean().construct_hits + +ef_construct_idx = ef_df.construct.cat.codes.values +n_ef_constructs = ef_df.construct.cat.categories.size + +ef_task_idx = ef_df.task.cat.codes.values +n_ef_tasks = ef_df.task.cat.categories.size + +with pm.Model() as model3: + + construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) + constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) + + nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 + nu = pm.Deterministic('nu', nu_minus_one+1) + + hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) + + display(pm.model_to_graphviz(model3)) + display(model3.check_test_point()) + + model3_trace = pm.sample(model=model3) + + display(pm.model_to_graphviz(model3)) + + display(pm.summary(model3_trace)) + pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) + + pm.traceplot(model3_trace) + pm.plot_posterior(model3_trace, + point_estimate='mode', + credible_interval=0.95, + ref_val=0) +az.plot_pair(model3_trace, + var_names=['construct_mu'], + divergences=True, + textsize=18) + +#%% Model4 + + +#%% Model Comparision: compare models using WAIC criterion +models = {'model1':model1, 'model2': model2, 'model3': model3} +mc_waic = pm.compare(models, ic='WAIC') +pm.compareplot(mc_waic) diff --git a/efo/20200116_tidy_efo.py b/efo/20200116_tidy_efo.py new file mode 100644 index 0000000..14b2db5 --- /dev/null +++ b/efo/20200116_tidy_efo.py @@ -0,0 +1,62 @@ +#%% [markdown] +# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: +# ,,,,, + +# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. + +# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. +#%% + +import pandas as pd +import seaborn as sns + +import matplotlib.pyplot as plt + +sns.set(color_codes=True) + +def tidy_efo_preproc_csv(csv, output_csv): + df = pd.read_csv(csv) + + tidy_df = pd.DataFrame({ + "context": 'notEF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], + "task_hits": df['task_hits'] - df['task_ef_hits'], + "construct_hits": df['concept_hits'] - df['concept_ef_hits'] + }) + + ef_df = pd.DataFrame({ + "context": 'EF', + "task": df['task'], + "construct": df['concept'], + "hits": df['task_concept_ef_hits'], + "task_hits": df['task_ef_hits'], + "construct_hits": df['concept_ef_hits'] + }) + + tidy_df = tidy_df.append(ef_df, ignore_index=True) + + return tidy_df + +# params +csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" +output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') + +# make things tidy! +df = tidy_efo_preproc_csv(csv_path, output_csv_path) + + +# exploratory diagrams +wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] + +sns.kdeplot(wm_df.task_hits) + +#sns.pairplot(ef_df) +#sns.distplot(ef_df.task_hits, rug=True) + +#f, ax = plt.subplots(figsize=(6, 6)) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) +#sns.rugplot(ef_df.task_hits, color="g", ax=ax) +#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) +#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/icom/vrc_pymc3.ipynb b/icom/vrc_pymc3.ipynb new file mode 100644 index 0000000..2c202dd --- /dev/null +++ b/icom/vrc_pymc3.ipynb @@ -0,0 +1,39 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNNvmpE7E8VdovmsMoHFy9r", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8C40rrzjENts" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/py/20191105_cirq.py b/py/20191105_cirq.py deleted file mode 100644 index afa9ada..0000000 --- a/py/20191105_cirq.py +++ /dev/null @@ -1,35 +0,0 @@ -# %% [markdown] -# # Cirq NISQ Payground -# Here are some code snippets that I'm playing with to learn quantum computing concepts -# -# use the following command to install cirq: -# ```bash -# pip install cirq -# ``` - -#%% -import cirq - - -grid_length = 3 - -qbits = [cirq.GridQubit(i,j) for i in range(grid_length) for j in range(grid_length)] - -circuit = cirq.Circuit() - -circuit.append([cirq.H(q) for q in qbits if (q.row + q.col) % 2 == 0], - strategy=cirq.InsertStrategy.EARLIEST) -circuit.append([cirq.X.on(q) for q in qbits if (q.row + q.col) % 2 == 1], - strategy=cirq.InsertStrategy.NEW_THEN_INLINE) - -print(circuit) - -# iterate over moment -for i, m in enumerate(circuit): - print('Moment {}: {}'.format(i, m)) - - -simulator = cirq.Simulator() -circuit.append(cirq.measure(*qbits, key='x')) -results = simulator.run(circuit, repetitions=100) -print(results.histogram(key='x')) \ No newline at end of file diff --git a/py/20191107_kl_divergence.py b/py/20191107_kl_divergence.py deleted file mode 100644 index 8827ef4..0000000 --- a/py/20191107_kl_divergence.py +++ /dev/null @@ -1,73 +0,0 @@ -# %% -import numpy as np -from scipy.stats import norm, poisson -from matplotlib import pyplot as plt -import seaborn as sns -sns.set() - -# %% [markdown] -# The following function calculates the KL-divergence of two distributions (p and q). -# -# The KL formula that is being used here is: -# -# $D_{KL}(P || Q)=\Sigma (p \times \log {p \over q})$ - -# %% -def kl(p, q): - """ - Calculates relative entropy a.k.a. Kullback–Leibler divergence. - """ - return np.sum(np.where(p!=0, p*np.log(p/q),0)) - - -# 1. generate example distributions -x = np.arange(-10,10,0.001) -p = norm.pdf(x,0,1) -q = norm.pdf(x,1,2) - -# 2. calc kl divergence -kl_score = kl(p, q) - -# plot distributiions -plt.title(f'KL(P||Q) = {kl(p,q):.2f}') -plt.plot(x,p) -plt.plot(x,q, color="red") -plt.show() - - -# %% -# [snippet[ plot poisson distribution generated by scipy -from scipy.stats import poisson as poi -r = poi.cdf(x, 0.9) -plt.plot(x, r, color="green") -plt.show() - -x = np.arange(20) -lambda_ = [1.5, 4.25] -colors = ["#348ABD", "#A60628"] - -# lambda = 1.5 -plt.bar(x, poi.pmf(x, 1.5), color="red", label="$\lambda = 1.5$", alpha=0.60, lw="3") - -plt.bar(x, poi.pmf(x, 4.5), color="blue", label="$\lambda = 4.5$", alpha=0.60, lw="3") - -plt.xticks(x + 0.4, x) -plt.ylabel("Probability of $k$") -plt.xlabel("$k$") -plt.show() - - -# %% -# [snippet] plot multiple exponentional distributions (EXP) -from scipy.stats import expon as expo - -x = np.linspace(0,4,100) -colors = ['red','blue','green'] -lambdas = [0.5, 1.0, 1.5] - -for l, c in zip(lambdas, colors): - y = expo.pdf(x, scale=1.0/l) - plt.plot(x, y, lw=2, color=c) - - -# %% diff --git a/py/20191223_pubmed.py b/py/20191223_pubmed.py deleted file mode 100644 index 3abc17d..0000000 --- a/py/20191223_pubmed.py +++ /dev/null @@ -1,117 +0,0 @@ -#%% temp (REMOVE this, this snippet sets an env var. That's it!) -import os -os.environ['NCBI_API_KEY'] = '' - -#%% direct eutils xml requests with history support -#Note: pip install xmltodict -import os -from datetime import date -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' -ts = date.today().strftime('%Y%m%d') - - -terms = ['Digit Span', 'Working Memory'] -db = 'pubmed' # or 'pmc' - - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f'Succesfully searched and stored results on history server.\nNow retriving {_num_of_results} abstracts...') - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - - -for term in terms: - print(f'searching NCBI for: {term}...') - search_and_store(term, db=db, output_file = f'data/{db}/{ts}_{db}_{term}.xml') - - -#%% [markdown] -# DEPRECATED: POST ids to history server -# The following code posts a list of ids to the history server and retrives parameters to fetch abstracts of the articles. Although it helps to avoid facing the NCBI query limitations, the same functionality can be achieved with esearch/usehistory + efetch. - -#%% POST - -url = f"{base}epost.fcgi" - -params = { - 'db': db, - 'id': ','.join(map(str, [11237011,12466850])), - 'api_key': os.environ['NCBI_API_KEY'] -} - -response = requests.post(url, params) - -history_params = xmltodict.parse(response.text) - -#%% [markdown] -# ## DEPRECATED: metapub -# The following snippet shows how to use metapub package to retrive a list of records for a given search query. It's limited by the number of returned records and limited requests rate per second (10 queries/s with an API_KEY). The code also requires `metapub` package, to be install with `pip install metapub`. - -# Note: metapub requires an env variable named `NCBI_API_KEY`. - -#%% metapub - -import os -from metapub import PubMedFetcher - -terms = ['N-Back', 'Working Memory'] - -fetcher = PubMedFetcher() - -for term in terms: - abstracts = [] - - ids = fetcher.pmids_for_query(query=f'({term}[TIAB])', retmax=1000000, since='2010', pmc_only=True) - print(f'fetching articles for {term}') - - for index, id in enumerate(ids[:10]): - print(f'{index} of {len(ids)}...') - article = fetcher.article_by_pmid(id) - if article.abstract is not None: - abstracts.append(article.pmid + '\n' + article.title + '\n' + article.abstract) - - with open(f'data/{db}/{term}.txt','w') as f: - f.write('\n\n'.join(abstracts)) diff --git a/py/20191225_cognitiveatlas.py b/py/20191225_cognitiveatlas.py deleted file mode 100644 index 3ebc575..0000000 --- a/py/20191225_cognitiveatlas.py +++ /dev/null @@ -1,113 +0,0 @@ -#%% [markdown] - -# the following code retrives all task names and cognitive concepts from cognitive atlas and stores them as a file. -# use `pip install cognitiveatlas` to install required packages. - -#%% get list of all tasks - -from cognitiveatlas.api import search, get_task, get_concept -import pandas as pd -from datetime import date - -import os -os.environ['NCBI_API_KEY'] = '751ff4edfab973bd0bc913ee84a0062bf009' - -tasks = get_task().pandas -concepts = get_concept().pandas - -tasks.to_pickle('data/cognitive_atlas/tasks.pkl') -concepts.to_pickle('data/cognitive_atlas/concepts.pkl') - -print(len(tasks.index)) -print(len(concepts.index)) - -#%% -import requests -import xmltodict - -base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/' - -def search_and_store(term, output_file, db='pubmed', api_key=os.environ['NCBI_API_KEY']): - """Search for a term and store all abstract in a file - """ - search_query = f'({term}[TIAB])' - url = f'{base}esearch.fcgi' - params = { - 'term': search_query.replace(' ','+'), - 'usehistory': 'y', - 'db': db, - 'retmax': 0, - 'reldate': 10 * 365, - 'api_key': api_key - } - - response = requests.get(url,params=params) - search_response = xmltodict.parse(response.text) - - #DEBUG print(search_response) - - _num_of_results = search_response['eSearchResult']['Count'] - - print(f"Succesfully searched and stored results for '{term}' on history server.\nNow retriving {_num_of_results} abstracts...") - - - # --- FETCH ABSRACTS - url = f'{base}efetch.fcgi' - params = { - 'db': db, - 'api_key': api_key, - 'WebEnv': search_response['eSearchResult']['WebEnv'], - 'query_key': search_response['eSearchResult']['QueryKey'], - 'rettype': 'abstract', - 'retmode': 'xml' - } - - response = requests.post(url, params) - - with open(f'{output_file}', 'w') as f: - f.write(response.text) - - print(f'Succesfully stored results to {output_file}') - - return None - - -def fetch_pubs(cogat_obj): - search_and_store(cogat_obj['name'], f"data/pubmed/{cogat_obj['id']}.xml") - -_ = tasks.apply(fetch_pubs, axis=1) -_ = concepts.apply(fetch_pubs, axis=1) -# %% Remove empty resultsets -import glob -import os - -def has_result(xml_file): - with open(xml_file) as f: - content = xmltodict.parse(f.read()) - print(xml_file, 'PubmedArticleSet' in content) - return ('PubmedArticleSet' in content) - - -for file_path in glob.glob('data/pubmed/*.xml'): - if not has_result(file_path): - print(f'Found an empty resultset, removing {file_path}...') - os.remove(file_path) - -#%% list of tasks and concepts without any result from pubmed and filter them out - -#%% count articles per task and concept - -#%% for each task, count related concepts - -#%% for each concept, count related tasks - -#%% count total articles - -#%% count unrelated articles for each task and concept - -#%% frequency tables for all task-concept pairs - -#%% measure task-task similarity - -#%% measure concept-concept similarity - diff --git a/py/20200116_efo_analysis.py b/py/20200116_efo_analysis.py deleted file mode 100644 index 348e7b1..0000000 --- a/py/20200116_efo_analysis.py +++ /dev/null @@ -1,163 +0,0 @@ -#%% [markdown] - -# The following cell prepares the environment, install the dependencies, and loads the tidy dataset as `df` - -#%% -#!pip install pymc3 pandas matplotlib numpy seaborn arviz - -import matplotlib.pyplot as plt - -import pandas as pd -import numpy as np - -import pandas as pd -import pymc3 as pm -import numpy as np - -from IPython.display import display -import seaborn as sns - -from scipy.stats import zscore - -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -#csv_path = '/content/drive/My Drive/Colab Notebooks/data/efo_pubmed_hits.20200114_preproc.csv' -csv_path = '/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_tidy.csv' - -df = pd.read_csv(csv_path) - -no_hits = df[(df.construct_hits==0) | (df.task_hits==0) | (df.hits==0)] -tasks_with_no_hits = no_hits[no_hits.task_hits==0].task.unique() -constructs_with_no_hits = no_hits[no_hits.construct_hits==0].construct.unique() - -print(f"The following {len(constructs_with_no_hits)} constructs have zero hits: {', '.join(constructs_with_no_hits)}") -print(f"The following {len(tasks_with_no_hits)} tasks have zero hits: {', '.join(tasks_with_no_hits)}") - - -# change task and concepts to categories -df['context'] = df['context'].astype('category') -df['construct'] = df['construct'].astype('category') -df['task'] = df['task'].astype('category') - -#DEBUG make it one observation per task! it this necessary? -#df = df.sort_values('task', ascending=False).drop_duplicates(['task']) - -df = df[~((df.task_hits ==0) | (df.construct_hits==0))] - -context_idx = df.context.cat.codes.values -n_context = df.context.cat.categories.size - -construct_idx = df.construct.cat.codes.values -n_constructs = df.construct.cat.categories.size - -task_idx = df.task.cat.codes.values -n_tasks = df.task.cat.categories.size - -n_obs = len(df) - -df['hits_zscore'] = zscore(df.hits) -df['task_hits_zscore'] = zscore(df.task_hits) -df['task_construct_zscore'] = zscore(df.construct_hits) - -#%% -# Model1 tries to predict/explain the task/construct hits using only an informative normal distribution - - -with pm.Model() as model1: - # prior on mean value - mu = pm.Normal('mu', sigma=100) - - # likelihood - hits = pm.Normal('hits', mu=mu, sigma=1, observed=df.hits_zscore) - - display(pm.model_to_graphviz(model1)) - display(model1.check_test_point()) - - model1_trace = pm.sample(1000, model=model1) - -# plot traceplot -az.plot_trace(model1_trace) - -#%% model 2: Model task-construct hits with priors on the context, then compare EF to nonEF. -# ----------------------------------------------- - -sd_contexts = df.groupby('context').std().hits_zscore -hits_grand_mean = df.hits_zscore.mean() #FIXME isn't it zero?! - -with pm.Model() as model2: - - # prior on `nu`, a parameter of final StudentT likelihood - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one + 1) - - # context parameters - context_mu = pm.Normal('context_mu', mu=hits_grand_mean, sigma=sd_contexts*100, shape=n_context) - context_sigma = pm.Uniform('context_sigma', sd_contexts/1000, sd_contexts*1000, shape=n_context) - - # difference between the avergae hits in EF and nonEF - ef_noef_diff = pm.Deterministic('EF - nonEF', context_mu[0] - context_mu[1]) - - # likelihood - hits = pm.StudentT('hits', nu=nu, mu=context_mu[context_idx], sigma=context_sigma[context_idx], observed=df.hits_zscore) - - display(pm.model_to_graphviz(model2)) - display(model2.check_test_point()) - model2_trace = pm.sample(model=model2) - - # plots - pm.traceplot(model2_trace, var_names=['context_mu','context_sigma','mi']) - pm.plot_posterior(model2_trace, - var_names=['context_mu','context_sigma','EF - nonEF','nu'], - point_estimate='mode', - credible_interval=0.95, - ref_val=0) - -#%% Model 3: predict `task-construct` hits, only in EF context, and then compare `construct` model parameters -# ----------------------------------------------- -ef_df = df[df.context=='EF'] -ef_construct_mean = ef_df.groupby('construct').mean().construct_hits - -ef_construct_idx = ef_df.construct.cat.codes.values -n_ef_constructs = ef_df.construct.cat.categories.size - -ef_task_idx = ef_df.task.cat.codes.values -n_ef_tasks = ef_df.task.cat.categories.size - -with pm.Model() as model3: - - construct_mu = pm.Normal('construct_mu', mu=ef_construct_mean, sigma=100, shape=n_ef_constructs) - constructs_sigma = pm.Uniform('construct_sigma', 1/100, 100, shape=n_ef_constructs) - - nu_minus_one = pm.Exponential('nu_minus_one',lam=1/29.0) # min(nu) must be 1 - nu = pm.Deterministic('nu', nu_minus_one+1) - - hits = pm.StudentT('hits', nu=nu, mu=construct_mu[ef_construct_idx], sigma=constructs_sigma[ef_construct_idx], observed=ef_df.hits) - - display(pm.model_to_graphviz(model3)) - display(model3.check_test_point()) - - model3_trace = pm.sample(model=model3) - - display(pm.model_to_graphviz(model3)) - - display(pm.summary(model3_trace)) - pm.forestplot(model3_trace, combined=True, var_names=['construct_mu'], credible_interval=0.95) - - pm.traceplot(model3_trace) - pm.plot_posterior(model3_trace, - point_estimate='mode', - credible_interval=0.95, - ref_val=0) -az.plot_pair(model3_trace, - var_names=['construct_mu'], - divergences=True, - textsize=18) - -#%% Model4 - - -#%% Model Comparision: compare models using WAIC criterion -models = {'model1':model1, 'model2': model2, 'model3': model3} -mc_waic = pm.compare(models, ic='WAIC') -pm.compareplot(mc_waic) diff --git a/py/20200116_tidy_efo.py b/py/20200116_tidy_efo.py deleted file mode 100644 index 14b2db5..0000000 --- a/py/20200116_tidy_efo.py +++ /dev/null @@ -1,62 +0,0 @@ -#%% [markdown] -# EFO kickoff project collects several data from PubMed in a wide format. Codes provided below converts the wide format into a tidy format with the following expected structure in each row: -# ,,,,, - -# the context column is either EF or notEF, which shows that the context in which the query was performed was either executive functions or anything expect executive function. Please refer to my daily log of 20200116 or efo/kickoff codebook for more details on columns. - -# The following code expects a csv file (preprocessed csv file), and generated a new csv with _tidy suffix instead of _preproc in the same directory. -#%% - -import pandas as pd -import seaborn as sns - -import matplotlib.pyplot as plt - -sns.set(color_codes=True) - -def tidy_efo_preproc_csv(csv, output_csv): - df = pd.read_csv(csv) - - tidy_df = pd.DataFrame({ - "context": 'notEF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_hits'] - df['task_concept_ef_hits'], - "task_hits": df['task_hits'] - df['task_ef_hits'], - "construct_hits": df['concept_hits'] - df['concept_ef_hits'] - }) - - ef_df = pd.DataFrame({ - "context": 'EF', - "task": df['task'], - "construct": df['concept'], - "hits": df['task_concept_ef_hits'], - "task_hits": df['task_ef_hits'], - "construct_hits": df['concept_ef_hits'] - }) - - tidy_df = tidy_df.append(ef_df, ignore_index=True) - - return tidy_df - -# params -csv_path = "/Users/morteza/workspace/efo_kickoff/datasets/efo_pubmed_hits.20200114_preproc.csv" -output_csv_path = csv_path.replace('_preproc.csv', '_tidy.csv') - -# make things tidy! -df = tidy_efo_preproc_csv(csv_path, output_csv_path) - - -# exploratory diagrams -wm_df = df[(df.context == 'EF') & (df.construct == 'Working Memory') & (df.task_hits<1000)] - -sns.kdeplot(wm_df.task_hits) - -#sns.pairplot(ef_df) -#sns.distplot(ef_df.task_hits, rug=True) - -#f, ax = plt.subplots(figsize=(6, 6)) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits, kind='kde', ax=ax) -#sns.rugplot(ef_df.task_hits, color="g", ax=ax) -#sns.rugplot(ef_df.construct_hits, color="b", vertical=True, ax=ax) -#sns.jointplot(ef_df.task_hits,ef_df.construct_hits) diff --git a/py/20200204_irt_pymc3.py b/py/20200204_irt_pymc3.py deleted file mode 100644 index 81fd873..0000000 --- a/py/20200204_irt_pymc3.py +++ /dev/null @@ -1,104 +0,0 @@ -#%% - -# 1. libraries -import pandas as pd -import numpy as np -import pymc3 as pm - -from scipy.special import expit -from scipy.stats import zscore -from IPython.display import display - - -import matplotlib.pyplot as plt -import seaborn as sns -import arviz as az - -# 2. setup themes for plots -sns.set_style('ticks') -az.style.use("arviz-darkgrid") - -# 3. a function to calculate logit -def irt_invlogit(ai,di): - return expit(d[int(di)] -a[int(ai)]) - -# 4. parameters -n_students = 100 -n_items = 10 - -# 5. Ground truth for abilities and difficulties -a = np.random.normal(0, 1, n_students) -d = np.random.normal(0, 1, n_items) - - # 6. probability of responding correctly; P is a matrix of probability values generated for each (student, item) pair -P = np.fromfunction(lambda i,j: np.vectorize(irt_invlogit)(i,j), (n_students, n_items)) - -# 7. observed reponses; R matrix contains success/failure -R = np.array(list(map(np.vectorize(lambda x: 1 if x > np.random.rand(1) else 0), P))) - -# 8. create a data frame to keep all data in a single place. Each row holds details of a single trial (a single cell in ability-difficulty matrix) -trials = pd.DataFrame(columns=["student","item","ability","difficulty","prob","response"]) - -# 9. fill up trial data frame with values from parameters, P, R, a, and, d -for i in range(n_students): - for j in range(n_items): - trials.loc[i*n_items+j] = [i,j,a[i], d[j], P[i,j], R[i,j]] - -# 10. student and item are categorical variables -trials['student'] = trials.student.astype('category') -trials['item'] = trials.item.astype('category') - -# DEBUG -#display(trials) - - -# 11. create a list of indices for students and items in the trial (to use when creating PyMC3 model) -student_idx = trials.student.cat.codes.values -item_idx = trials.item.cat.codes.values - -# 12. specify PyMC3 mdoel -with pm.Model() as model: - - # 12.1. model student abilities as N(0,1), one parameter per student - ability = pm.Normal('ability', mu=0, sigma=1, shape=n_students) - - # 12.2. model item difficulty as N(0,1), one parameter per item - difficulty = pm.Normal('difficulty', mu=0, sigma=1, shape=n_items) - - # 12.3. model probaility that a student responds correctly to an item (using invlogit function) - p = pm.Deterministic('p', pm.math.invlogit(difficulty[item_idx]-ability[student_idx])) - - # 12.4. model likelihood for R (bernolli) - R_obs = pm.Bernoulli('R_obs', p=p, observed=trials.response) - - # 12.5. show model diagram - display(pm.model_to_graphviz(model)) - - # DEBUG - #display(model.check_test_point()) - -# 13. MCMC model fitting -trace = pm.sample(1000, model=model) - -# DEBUG (MAP method) -#map_estimate = pm.find_MAP(model) - -# 14. plot posteriors for student abilities -#pm.plot_posterior(trace,var_names=['ability']) - -# 15. extract diagnostics and posteriors (only for ability here) -a_trace_summary = pm.summary(trace, var_names=['ability']) -a_est = a_trace_summary['mean'].values - -d_trace_summary = pm.summary(trace, var_names=['difficulty']) -d_est = d_trace_summary['mean'].values - -# 15. report correlation between ground truth and estimated params -print("correlation of ground truth and estimated models:") -print("abilities:\t", np.corrcoef(a,a_est)[0,1]) -print("difficulties:\t", np.corrcoef(d,d_est)[0,1]) - - - - -# %% diff --git a/py/20200221_experiment_scheduling.py b/py/20200221_experiment_scheduling.py deleted file mode 100644 index 9beec24..0000000 --- a/py/20200221_experiment_scheduling.py +++ /dev/null @@ -1,177 +0,0 @@ -#%% [markdown] -# Complex cognitive experiments require participants to perform multiple tasks across a span of limited lab time or online crowdsourcing time, hence demand flexible scheduling of tasks. -# This notebook demonstrates a possible solution for the problem of scheduling experimental tasks, and mainly concerns reformulating experiments as a resource allocation problem. -# -# Typical experiments are comprised of several session, in each session participants view a set of questionnaires, perform a test, and then respond to another set of questionnaires. This structure is repeated for each srssion throughout the experiment. - -# To orgnaize questionniare and tasks in a limited time, we first model a study as an ordered list of sessions (here, for example, 12 session). Sessions consist of several questionnaires before and after a set of experimental tasks. We then define constraints on sueverys and tasks (e.g., pre-task, post-task, end of study, and start of study surveys), and solve for a schedule for the given scenario. Note that his example scenario only plans the experiment for a single subject. -# -# Note: Use the following command to install dependencies: `pip install pyschedule` - -#%% -from math import ceil - -from pyschedule import Scenario, plotters, alt -from pyschedule.solvers.mip import solve -from pyschedule.plotters.matplotlib import plot - -import seaborn as sns - -# 1. set theme and style -sns.color_palette("colorblind") -sns.set_style('white') -# experiment duration in minutes -session_duration = 60 -game_duration = 45 -n_subjects = 2 -n_sessions = 12 -duration_per_question = .16 # minutes (~10sec) - -prestudy_tasks = [ - "xcit_demographics" -] - -pregame_tasks = [ - -] - -postgame_tasks = [ - "nasa_tlx", - "xcit_postgame_debrief" -] - -poststudy_tasks = [ - "xcit_poststudy_debrief" -] - -n_questions = { - "xcit_demographics": 20, - "aiss": 20, - "arces": 12, - "asrs": 18, - "avg2019": 16, - "bfi_2_par1": 30, - "bfi_2_part2": 30, - "bisbas": 24, - "bis11": 12, - "cfq": 25, - "cfs": 12, - "dyslexia": 15, - "ehi_sf": 4, - "grit12": 12, - "i_panas_sf": 10, - "ipaq_sf": 7, - "maas": 15, - "mfs": 12, - #"mmi_part1": 66, - "mw": 8, - "mwq": 5, - "ncs_6": 6, - "nfc": 18, - "psqi": 9, - "rei": 40, - "sci": 8, - "sqs": 28, - "upps_sf": 20, - "webexec": 12, - "who5": 5, - "whoqol": 26, - "xcit_poststudy_debrief": 20, - "nasa_tlx": 6, - "xcit_postgame_debrief": 15 -} - - -# 1. define the study -s = Scenario('Prolific500', horizon=session_duration) -# 2. sessions -sessions = s.Resources('Session', num = n_sessions) - - -def _duration(questions): - t = ceil(questions * duration_per_question) - return t - -# 3. games -games = s.Tasks('Game',length=game_duration, num=n_sessions, is_group=False, delay_cost=1) -games += alt(sessions) - -# 3. questionnaires -for q in n_questions.keys(): - n = n_questions.get(q, 0) - task = s.Task(q, length= _duration(n), delay_cost=1) - - if q in prestudy_tasks: - task += sessions[0] # first session - task.delay_cost = 2 - s += task < games - elif q in poststudy_tasks: - task += sessions[-1] # last session - task.delay_cost = -2 - s += games < task - elif q in postgame_tasks: - task += sessions - s += games < task - elif q in pregame_tasks: - task += sessions - s += task < games - else: - task += alt(sessions) - -print(s.tasks) - -# 4. solve resource allocation -solve(s) - -# 5. print last computed solution -print(s.solution()) - -# 6. pot gantt -plot(s, fig_size=(50,5)) - -#%% -# MPILX Scheduling -from pyschedule import Scenario, solvers, plotters, alt - -# experiment duration for each subject in minutes -study_duration = 12 * 24 * 60 # days * hours * minutes -n_subjects = 2 -task_durations = { - 'pretest_presurvey': 30, - 'pretest_DWI': 15, - 'pretest_rsfMRI': 15, - 'pretest_anatomical': 15, - 'pretest_taskfMRI': 45, - 'pretest_postsurvey': 30, - 'pretest_presurvey': 30, - 'training_presurvey': 30, - 'training_': 10 * 24 * 60, #TODO expand to daily - 'training_postsurvey': 30, - 'posttest_DWI': 15, - 'posttest_rsfMRI': 15, - 'posttest_anatomical': 15, - 'posttest_taskfMRI': 45, - 'posttest_postsurvey': 30 -} - -# the planning horizon has -s = Scenario('MPILX50', horizon=study_duration) - -subject = s.Resource('subject', num=n_subjects) - -tasks = list() - -for t in task_durations.keys(): - duration = task_durations[t] - task = s.Task(t, length=duration, delay_cost=1) - task += alt(subject) - tasks.append(task) - -for i in range(len(tasks)-1): - s += tasks[i] < tasks[i+1] - -# compute and print session schedules -solvers.mip.solve(s) -print(s.solution()) - -plotters.matplotlib.plot(s) diff --git a/py/attentional_blink_sequence_generator.py b/py/attentional_blink_sequence_generator.py deleted file mode 100644 index 64baf84..0000000 --- a/py/attentional_blink_sequence_generator.py +++ /dev/null @@ -1,49 +0,0 @@ - -#%% [markdown] -# to run the web app, change the current directory to where the file is located and use the following command: -# `streamlit run attentional_blink_sequence_generator.py` -# -# You need to install `streamlit` package before running the web app: -# `pip install streamlit` - -#%% - -import random - -import streamlit as st - -st.title('Attentional Blink Sequence Generator') - -num_of_sequences = st.sidebar.slider('Number of sequences', value=10) -sequence_size = st.sidebar.slider('Sequence size', value=20, min_value=10, max_value=22) -lag = st.sidebar.selectbox('Lag', [1,7]) -items = st.sidebar.text_input('Items','ABCDEFGHIJKLMNOPQRSTUVWY') -T1_position = st.sidebar.selectbox('T1 Position', [4,9]) -T2 = st.sidebar.selectbox('T2', ['X', 'Z']) -T2_position = T1_position + lag - -# randomlized raw python parameters -#num_of_sequences = 10 -#sequence_size = 20 -#T1_positions = [4, 9] -#T2_options = ['X', 'Z'] -#lags= [1, 7] -#items = 'ABCDEFGHIJKLMNOPQRSTUVWY' -#T1_position = T1_positions[random.randint(0,1)] -#T2 = T2_options[random.randint(0,1)] - - -st.header('Sequences') - -for i in range(num_of_sequences): - sequence = list(items) - random.shuffle(sequence) - sequence.insert(T2_position, T2) - T1 = sequence[T1_position] - sequence = sequence[0:sequence_size] - - # insert markdown signs to highlight T1 and T2 - sequence[T1_position] = f' **{T1}** ' - sequence[T2_position] = f' **{T2}** ' - st.write(''.join(sequence)) - diff --git a/py/brain2_playground.py b/py/brain2_playground.py deleted file mode 100644 index e69de29..0000000 --- a/py/brain2_playground.py +++ /dev/null diff --git a/py/contiguous_seqs.ipynb b/py/contiguous_seqs.ipynb deleted file mode 100644 index 44905ae..0000000 --- a/py/contiguous_seqs.ipynb +++ /dev/null @@ -1,57 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "name": "stdout", - "text": [ - "a\nab\nabc\nb\nbc\nbcd\nc\ncd\ncde\nd\nde\ndef\ne\nef\nf\n" - ], - "output_type": "stream" - } - ], - "source": "original_seq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027]\nmin_len \u003d 1\nmax_len \u003d 3\n\n\ncontig_seqs \u003d list()\n\nfor st in range(len(original_seq)):\n min_fin_index \u003d st + min_len\n max_fin_index \u003d min(st + max_len, len(original_seq)) + 1\n\n for fin in range(min_fin_index, max_fin_index):\n seq \u003d original_seq[st:fin]\n contig_seqs.append(seq)\n\nfor cs in contig_seqs:\n print(\u0027\u0027.join(cs))\n" - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": "from scipy import stats\nimport heapq # to extract n largest values with nlargest()\n\n# PARAMS\n\nseq \u003d [\u0027a\u0027,\u0027b\u0027,\u0027c\u0027,\u0027d\u0027,\u0027e\u0027,\u0027f\u0027,\u0027e\u0027] # trials\nN \u003d 2 # N as in N-Back\n\n\ntrials \u003d len(seq)\n\ndef count_targets_and_lures():\n # the first trials are distractors\n mask \u003d \u0027D\u0027 * N\n for index in range(N, trials):\n if seq[index] \u003d\u003d seq[index - N]:\n mask +\u003d \u0027T\u0027\n elif seq[index] in seq[index - N - 1:index - N + 1]:\n mask +\u003d \u0027L\u0027\n else:\n mask +\u003d \u0027D\u0027\n return mask.count(\u0027T\u0027), mask.count(\u0027L\u0027)\n\n\ntargets,lures \u003d count_targets_and_lures()\ntargets_norm \u003d stats.norm(targets, 0.5)\nskewness_norm \u003d stats.norm(0, 0.5)\n\ndef skewness_cost(choices):\n even_ratio \u003d len(seq) / len(choices)\n costs \u003d {c: abs(seq.count(c) - even_ratio) for c in choices}\n max_deviation_from_even_dist \u003d max(list(costs.values()))\n cost \u003d 1.0 - (skewness_norm.pdf(max_deviation_from_even_dist) / skewness_norm.pdf(0))\n return cost\n\n\n\ndef lures_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\n\ndef targets_ratio_cost():\n return 1.0 - targets_norm.pdf(targets)\n\ndef ralph2014_skewness(choices):\n freqs \u003d [float(seq.count(c)) for c in choices]\n ralph_skewed \u003d sum(heapq.nlargest(int(len(choices) / 2), freqs)) \u003e (trials * 2 / 3)\n return ralph_skewed", - "metadata": { - "pycharm": { - "metadata": false, - "name": "#%%\n" - } - } - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/ddm_playground.ipynb b/py/ddm_playground.ipynb deleted file mode 100644 index be389b6..0000000 --- a/py/ddm_playground.ipynb +++ /dev/null @@ -1,48 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "\u003cFigure size 432x288 with 1 Axes\u003e", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": "from ddm import Model\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nm \u003d Model()\ns \u003d m.solve()\nplt.plot(s.model.t_domain(), s.pdf_corr())\nplt.show()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/glm.ipynb b/py/glm.ipynb deleted file mode 100644 index b11d62b..0000000 --- a/py/glm.ipynb +++ /dev/null @@ -1,64 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": "GLM Playgorund\n", - "metadata": { - "pycharm": { - "metadata": false - } - } - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false - } - }, - "outputs": [ - { - "data": { - "text/plain": "3" - }, - "metadata": {}, - "output_type": "execute_result", - "execution_count": 17 - } - ], - "source": "#!conda install --yes statsmodel\na \u003d 1+2\na\n\n\nfrom statsmodels.formula.api import ols\n\nmy_data \u003d {}\n\nmodel \u003d ols(formula\u003d\"y~X\", data\u003dmy_data).fit()\n" - } - ], - "metadata": { - "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" - }, - "kernelspec": { - "name": "python3", - "language": "python", - "display_name": "Python 3" - }, - "stem_cell": { - "cell_type": "raw", - "source": "", - "metadata": { - "pycharm": { - "metadata": false - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/py/gym_dqn.py b/py/gym_dqn.py deleted file mode 100644 index eac09ae..0000000 --- a/py/gym_dqn.py +++ /dev/null @@ -1,41 +0,0 @@ -# %% Keras-RL for gym cart pole - -import gym -from rl.policy import EpsGreedyQPolicy, LinearAnnealedPolicy -from rl.memory import SequentialMemory -from rl.agents.dqn import DQNAgent - -# 1. model -def build_model(state_size, num_actions): - input = Input(shape=(1,state_size)) - x = Flatten()(input) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - x = Dense(16, activation='relu')(x) - output = Dense(num_actions, activation='linear')(x) - model = Model(inputs=input, outputs=output) - print(model.summary()) - return model - -model = build_model() - -# 2. memory -memory = SequentialMemory(limit=50000, window_length=1) - -# 3. policy (decay eps) - -policy = LinearAnnealedPolicy( - EpsGreedyQPolicy(), - attr='eps', - value_max=1., - value_min=.1, - value_test=.05, - nb_steps=10000) - -# 4. agent - -dqn = DQNAgent( - model=model, nb_actions=num_actions, memory=memory, nb_steps_warmup=10, - target_model_update=1e-2, policy=policy) - -dqn.compile(Adam(lr=1e-3), metrics=['mae']) \ No newline at end of file diff --git a/py/nilearn_playground.ipynb b/py/nilearn_playground.ipynb deleted file mode 100644 index e05f854..0000000 --- a/py/nilearn_playground.ipynb +++ /dev/null @@ -1,207 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/morteza/miniconda3/lib/python3.7/site-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n", - " warnings.warn(msg, category=DeprecationWarning)\n" - ] - } - ], - "source": [ - "from nilearn import plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_glass_brain(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plotting.plot_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from nilearn import image, plotting\n", - "img = image.load_img(\"/Users/morteza/fsl_course_data/intro/structural.nii.gz\")\n", - "img = image.smooth_img(img, fwhm=4)\n", - "plotting.plot_img(img)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nilearn datasets: ['/Users/morteza/nilearn_data']\n", - "\n", - "Dataset created in /Users/morteza/nilearn_data/nyu_rest\n", - "\n", - "Downloading data from http://www.nitrc.org/frs/download.php/1071/NYU_TRT_session1a.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 697388519 of 697388519 bytes (100.0%, 0.0s remaining) ...done. (354 seconds, 5 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1a.tar.gz..... done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading data from http://www.nitrc.org/frs/download.php/1072/NYU_TRT_session1b.tar.gz ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloaded 653093650 of 653093650 bytes (100.0%, 0.0s remaining) ...done. (273 seconds, 4 min)\n", - "Extracting data from /Users/morteza/nilearn_data/nyu_rest/2a70e1b81bc76ba32ae0e1b7e5891a7b/session1/NYU_TRT_session1b.tar.gz..... done.\n" - ] - }, - { - "ename": "AttributeError", - "evalue": "images", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'images'", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"nilearn datasets: {datasets.get_data_dirs()}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch_nyu_rest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_stat_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mplotting\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_glass_brain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/lib/python3.7/site-packages/sklearn/utils/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 107\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setstate__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: images" - ] - } - ], - "source": [ - "from nilearn import datasets, plotting\n", - "print(f\"nilearn datasets: {datasets.get_data_dirs()}\")\n", - "dataset = datasets.fetch_nyu_rest()\n", - "plotting.plot_stat_map(dataset.images[0])\n", - "plotting.plot_glass_brain(dataset.images[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/py/pandas.ipynb b/py/pandas.ipynb deleted file mode 100644 index b003ea9..0000000 --- a/py/pandas.ipynb +++ /dev/null @@ -1,135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true, - "pycharm": { - "is_executing": false, - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['head', 'tail', 'head', 'head', 'head', 'head', 'head', 'tail', 'tail', 'head']\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "np.random.seed(123)\n", - "coins = []\n", - "coins_random_walk = [0]\n", - "for i in range(10):\n", - " if np.random.randint(0,2) == 0:\n", - " coins_random_walk.append(0)\n", - " coins.append(\"head\")\n", - " else:\n", - " coins.append(\"tail\")\n", - "print(coins)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "A = [1,2,3]\n", - "B = A + [4,5]\n", - "B.append(6)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false, - "pycharm": { - "is_executing": false, - "name": "#%% \n" - } - }, - "outputs": [ - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAfmElEQVR4nO3de5hVdd338fdHDjognnUs0KAk8wTcOCCo6RiJhzDsdIvlKbPRLq3bSssOT9pt3Y+VdVtpIlcZHTUzKZ8yw8qtpkggmAGGEQICmgQKbkBhZr7PH2tBm+3MMLNm1p494+d1XfuatX6/31r7u5duP67DXksRgZmZWRa7dHcBZmbWczlEzMwsM4eImZll5hAxM7PMHCJmZpaZQ8TMzDJziJh1MUmflfTdNvovkPSnStZklpe+3V2AWU8jqVgyOwB4BWhK5y+OiP8pGTsUeBroFxGNlarRrFIcImYdFBG7b5uWtAy4KCJ+330VmXUfH84y62KSrpH043T2wfTvi5KKksa3MP4tku6TtE7SYkn/WblqzTrHIWKWrxPSv3tFxO4RMau0U9JA4D7gp8ABwNnAdyQdUdkyzbJxiJh1r0nAsoj4fkQ0RsQ84BfAe7u5LrN28TkRs+71BuAYSS+WtPUFftRN9Zh1iEPELF87u032M8ADEXFyJYox62o+nGWWrzVAM/DGVvp/DbxZ0rmS+qWvMZIOq1yJZtk5RMxyFBGbgC8DD0t6UdK4sv6XgInAFGA18BzwFWDXStdqloX8UCozM8vKeyJmZpaZQ8TMzDJziJiZWWYOETMzy6xX/U5kv/32i6FDh3Z3GWYGbNy4kYEDB3Z3GVWhmrfFY4899q+I2D/r8r0qRIYOHcrcuXO7uwwzAwqFAvX19d1dRlWo5m0haXlnlvfhLDMzy8whYmZmmTlEzMwsM4eImZll5hAxM7PMetXVWdazbGnawl+e+wt/fPqPrHt5Hfvstg8nDT2JkQeOZNe+vv+gWU/gELFusW7zOr4+6+us2rCKPXbdg9367saql1Zx05ybGLzHYD45/pPsO2Df7i7TzHYi18NZkv5L0gJJCyVd3kK/JH1L0hJJT0gaXdJ3qqTFad9VedZpldXU3MQ3Z3+TNRvXMHSvoexTsw8D+g1gn5p9GLb3MNZtXscNs2+gqbmpu0s1s53ILUQkHQl8GBgLjAQmSRpeNuw0YHj6agBuTpftA9yU9h8OnC3p8LxqtcpavHYxy19czusHvb7F/gN3P5Bn1j/Dk/96ssKVmVlH5bknchjwaERsiohG4AHgXWVjJgM/jMSjwF6SXkcSPEsiYmlEbAFuT8daLzB75Wx27dP2OY+avjXMemZWhSoys6zyPCeyAPiypH2BzcDpQPk9SQaTPGN6m5VpW0vtx7T0JpIaSPZiqK2tpVAodEXtlqOBGwdyfBxP32Lr//q9qflN9H+uv/959mDFYtH//FK9eVvkFiIR8aSkrwD3AUXgL0Bj2TC1tGgb7S29zzRgGkBdXV1U6/1p7N/uWHgHD/zjAYbsPqTVMSs3rORtB7+N+qPqK1eYdalqvl9UpfXmbZHrifWI+F5EjI6IE4B1wN/LhqwEDiqZH0LynOnW2q0XOPagY2lsbqQ5mlvsjwgamxs57qDjKlyZmXVU3ldnHZD+PRh4N3Bb2ZC7gfPSq7TGAesj4llgDjBc0jBJ/YEp6VjrBQYPGszxBx/PsheXvSpImqOZZS8uY/yQ8Ry858HdVKGZtVfevxP5RXpOZCtwaUS8IOkSgIiYCtxDcq5kCbAJ+GDa1yjpMuB3QB/g1ohYmHOtViGSOH/k+fTfpT/3L78fAvr16cfWpq0A1A+t5wMjPoDU0lFNM6smuYZIRLy1hbapJdMBXNrKsveQhIz1Qv369OO8Uedx+ptPZ/6z83lh8wvsXbM3ow4cxf4DMz8fx8wqzL9Yt26134D9OPlNJ3d3GWaWkW/AaGZmmTlEzMwsM4eImZll5hAxM7PMHCJmZpaZQ8TMzDJziJiZWWYOETMzy8whYmZmmTlEzMwsM4eImZll5hAxM7PMHCJmZpaZQ8TMzDJziJiZWWa5Pk9E0seBi4AA/gp8MCJeLum/EvhASS2HAftHxDpJy4CXgCagMSLq8qzVzMw6Lrc9EUmDgY8BdRFxJMljbqeUjomIr0XEqIgYBXwGeCAi1pUMOSntd4CYmVWhvA9n9QVqJPUFBgCr2xh7NnBbzvWYmVkXyu1wVkSsknQ9sALYDMyMiJktjZU0ADgVuKx0FcBMSQHcEhHTWlm2AWgAqK2tpVAodN2HMLPMisWiv4+p3rwtcgsRSXsDk4FhwIvAzyWdExE/bmH4GcDDZYeyjouI1ZIOAO6T9LeIeLB8wTRcpgHU1dVFfX19V38UM8ugUCjg72OiN2+LPA9nvR14OiLWRMRW4C7g2FbGTqHsUFZErE7/Pg/MAMbmWKuZmWWQZ4isAMZJGiBJwATgyfJBkvYETgR+VdI2UNKgbdPARGBBjrWamVkGeZ4TmS3pTmAe0AjMB6ZJuiTtn5oOfRfJ+ZKNJYvXAjOS7KEv8NOIuDevWs3MLJtcfycSEVcDV5c1Ty0bMx2YXta2FBiZZ21mZtZ5/sW6mZll5hAxM7PMHCJmZpaZQ8TMzDJziJiZWWYOETMzy8whYmZmmTlEzMwsM4eImZll5hAxM7PMHCJmZpaZQ8TMcrP77rvvMD99+nQuu+yyVkZ3zrHHtvakCcuTQ8TMqlZjY2O7xz7yyCM5VmKtcYiYWbdYs2YN73nPexgzZgxjxozh4YcfBuCaa66hoaGBiRMnct5559HU1MSVV17JmDFjGDFiBLfcckuL69u21/Pss89ywgknMGrUKI488kgeeuihV4296qqrOPzwwxkxYgRXXHEFAMuXL2fChAmMGDGCCRMmsGLFCgAuuOACPvKRj3DSSSfxxje+kQceeIALL7yQww47jAsuuGD7OmfOnMn48eMZPXo073vf+ygWi125uapXRPSa19FHHx1mVh3uv//+2GWXXWLkyJHbXwcddFBceumlERFx9tlnx0MPPRQREcuXL4+3vOUtERFx9dVXx+jRo2PTpk0REXHLLbfEtddeGxERL7/8chx99NGxdOnSV73fwIEDIyLi+uuvjy996UsREdHY2BgbNmzYYdzatWvjzW9+czQ3N0dExAsvvBAREZMmTYrp06dHRMT3vve9mDx5ckREnH/++XHWWWdFc3Nz/PKXv4xBgwbFE088EU1NTTF69OiYP39+rFmzJt761rdGsViMiIjrrrsuvvjFL+6wLaoVMDc68d/dXJ8nIunjwEVAAH8FPhgRL5f015M80fDptOmuiPjvtO9U4JtAH+C7EXFdnrWaWderqanh8ccf3z4/ffp05s6dC8Dvf/97Fi1atL1vw4YNvPTSSwC8853vpKamBkj+D/+JJ57gzjvvBGD9+vX8/e9/Z9iwYS2+55gxY7jwwgvZunUrZ555JqNGjdqhf4899mC33Xbjoosu4h3veAeTJk0CYNasWdx1110AnHvuuXzqU5/avswZZ5yBJI466ihqa2s56qijADjiiCNYtmwZK1euZNGiRRx33HEAbNmyhfHjx2fcaj1LbiEiaTDwMeDwiNgs6Q6SZ6lPLxv6UERMKlu2D3ATcDKwEpgj6e6IWISZ9QrNzc3MmjVre1iUGjhw4PbpiODb3/42p5xySrvWe8IJJ/Dggw/ym9/8hnPPPZcrr7yS8847b3t/3759+fOf/8wf/vAHbr/9dm688Ub++Mc/vmo96ZNVAdh1110B2GWXXbZPb5tvbGykT58+nHzyydx2223tqrE3yfucSF+gRlJfYACwup3LjQWWRMTSiNgC3A5MzqlGM+sGEydO5MYbb9w+X7rHUuqUU07h5ptvZuvWrQA89dRTbNy4scWxkJzbOOCAA/jwhz/Mhz70IebNm7dDf7FYZP369Zx++unccMMN29/32GOP5fbbbwfgJz/5Cccff3y7P8u4ceN4+OGHWbJkCQCbNm3iqaeeavfyPVmez1hfJel6YAWwmeQ56jNbGDpe0l9IAuaKiFgIDAaeKRmzEjimpfeR1AA0ANTW1lIoFLruQ5hZZsVikaamph2+k3/7299YtWoVhUKBs846ixtuuIGpU6fS1NTEiBEj+MQnPsGyZcuoqanZvtwhhxzCwIEDOfTQQ4kI9tprL6699tpXXT687b3uvfdefvazn9G3b19qamr4zGc+s0MNa9eu5fOf/zxbtmwhImhoaKBQKPD+97+fr371q1xzzTXsueeefPrTn6ZQKPDcc8+xcOFC9ttvP5577jk2bty4fX2lfZdffjmTJk3aHnYXXnjh9sNbxWKx1/63Scl5lRxWLO0N/AI4C3gR+DlwZ0T8uGTMHkBzRBQlnQ58MyKGS3ofcEpEXJSOOxcYGxEfbes96+rqYtvxVjPrXoVCgfr6+u4uoypU87aQ9FhE1GVdPs/DWW8Hno6INRGxFbgL2OHXQBGxISKK6fQ9QD9J+5HseRxUMnQI7T8UZmZmFZJniKwAxkkaoOQM1QTgydIBkg5M+5A0Nq1nLTAHGC5pmKT+JCfk786xVjMzyyDPcyKzJd0JzAMagfnANEmXpP1TgfcCH5HUSHLeZEp63XKjpMuA35Fc4ntreq7EzMyqSK6/E4mIq4Gry5qnlvTfCNxIC9LDW/fkV52ZmXWWb3tiZmaZOUTMzCwzh4iZmWXmEDEzs8wcImZmlplDxMzMMnOImJlZZg4RMzPLzCFiZmaZOUTMzCwzh4iZmWXmEDEzs8wcImZmlplDxMzMMnOImJlZZrmGiKSPS1ooaYGk2yTtVtb/AUlPpK9HJI0s6Vsm6a+SHpfkB6ebmVWh3EJE0mDgY0BdRBxJ8oTCKWXDngZOjIgRwLXAtLL+kyJiVGceIm9mZvnJ9cmG6fprJG0FBgCrSzsj4pGS2UeBITnXY2ZmXSi3PZGIWAVcD6wAngXWR8TMNhb5EPDb0lUAMyU9JqkhrzrNzCy73PZEJO0NTAaGAS8CP5d0TkT8uIWxJ5GEyPElzcdFxGpJBwD3SfpbRDzYwrINQANAbW0thUKh6z+MmXVYsVj09zHVm7dFnoez3g48HRFrACTdBRwL7BAikkYA3wVOi4i129ojYnX693lJM4CxwKtCJCKmkZ5Lqauri/r6+lw+jJl1TKFQwN/HRG/eFnlenbUCGCdpgCQBE4AnSwdIOhi4Czg3Ip4qaR8oadC2aWAisCDHWs3MLIPc9kQiYrakO4F5QCMwH5gm6ZK0fyrwBWBf4DtJztCYXolVC8xI2/oCP42Ie/Oq1czMssn16qyIuBq4uqx5akn/RcBFLSy3FBhZ3m5mZtXFv1g3M7PMHCJmZpZZq4ezJO3T1oIRsa7ryzEzs56krXMij5H84E8t9AXwxlwqMjOzHqPVEImIYZUsxMzMep6dnhNR4hxJ/yedP1jS2PxLMzOzateeE+vfAcYD70/nXwJuyq0iMzPrMdrzO5FjImK0pPkAEfGCpP4512VmZj1Ae/ZEtkrqQ3IyHUn7A825VmVmZj1Ce0LkW8AMoFbSl4E/Af+Ta1VmZtYj7PRwVkT8RNJjJDdQBDgzIp5saxkzM3ttaO+9swaQPN42gJr8yjEzs56kPZf4fgH4AbAPsB/wfUmfz7swMzOrfu3ZEzkb+I+IeBlA0nUkt3f/Up6FmZlZ9WtPiCwDdgNeTud3Bf6RV0HW9V55BZ56Kvl74IEweDCopZvZmJl1UFs3YPw2yTmQV4CFku5L508muULLeoBZs+BHP4KX0/8FaG6GI46AhgbYc8/urc3Mer62zonMJbkJ4wzgs8D9QAH4HPDb9qxc0sclLZS0QNJtknYr65ekb0laIukJSaNL+k6VtDjtu6qDn8uABQvg5pth0CA4+ODk9YY3wOLF8I1vQFNTd1doZj1dWzdg/EFnVixpMPAx4PCI2CzpDmAKML1k2GnA8PR1DHAzcEz648abSPZ6VgJzJN0dEYs6U9NrSQTMmAF77QU1JdfTSTBkCCxbBosWwVFHdVuJZtYLtOfqrOGS7pS0SNLSba92rr8vUCOpL8llwqvL+icDP4zEo8Bekl4HjAWWRMTSiNgC3J6OtXbavBmWLoW99265v1+/JETMzDqjPSfWv0/ynPT/BU4CPkjLzxjZQUSsknQ9sALYDMyMiJllwwYDz5TMr0zbWmo/pqX3kdQANADU1tZSKBR2/oleAyLgxBOhf/+WT6IPG5b0eXNZXorFor+Pqd68LdoTIjUR8QdJiojlwDWSHiIJllZJ2ptk72EY8CLwc0nnRMSPS4e1sGhbD8J6dWPENGAaQF1dXdTX1+/s87xmfPWrsHw57L//ju0RyeGsz34WDj20W0qz14BCoYC/j4nevC3ac++slyXtAvxd0mWS3gUc0I7l3g48HRFrImIrcBdwbNmYlcBBJfNDSA55tdZuHfDud8OmTbBhw7/bmppgxQo4/HAYPrz7ajOz3qE9IXI5yfmMjwFHA+cA57VjuRXAOEkDJInk3lvl99y6GzgvvUprHLA+Ip4F5gDDJQ1Lbzs/JR1rHXDIIXDFFdCnT7JH8swzsGoVHHccfPSjsEt7/umbmbWhPTdgnJNOFknOh5Ce65i9k+VmS7qT5NftjcB8YJqkS9L+qcA9wOnAEmDTtvVHRKOky4Dfkdyz69aIWNjhT2cccQR85SvJ3scrr0BtbXLFlplZV2jvDRjL/Sdwxc4GRcTVvPrcydSS/gAubWXZe0hCxjppl11g6NDursLMeqOsBzR80wwzM2vztif7tNaFQ8TMzGj7cNZjtH657ZZ8yjEzs56krdueDKtkIWZm1vP4Ik8zM8vMIWJmZpm1GiKS7pE0tHKlmJlZT9PWnsh0YKakz0nqV6F6zMysB2nrxPodkn4DfAGYK+lHQHNJ/zcqUJ+ZmVWxnf1ifSuwkeS56oMoCREzM7O2fmx4KvANkhsfjo6ITRWryszMeoS29kQ+B7zPNz40M7PWtHVO5K2VLMTMzHoe/07EzMwyc4iYmVlmuYWIpEMlPV7y2iDp8rIxV5b0L5DUtO3uwZKWSfpr2jc3rzrNzCy7rA+l2qmIWAyMApDUB1gFzCgb8zXga+mYM4CPR8S6kiEnRcS/8qrRzMw6p1KHsyYA/4iI5W2MORu4rUL1mJlZF8htT6TMFNoICEkDgFOBy0qag+S2KwHcEhHTWlm2AWgAqK2tpVAodFXNZtYJxWLR38dUb94WSh5znuMbSP2B1cAREfHPVsacBZwTEWeUtL0+IlZLOgC4D/hoRDzY1nvV1dXF3Lk+fWJWDQqFAvX19d1dRlWo5m0h6bGIqMu6fCUOZ50GzGstQFKv2lOJiNXp3+dJzqWMza1CMzPLpBIh0ua5Dkl7AicCvyppGyhp0LZpYCKwIOc6zcysg3I9J5Ke6zgZuLik7RKAiJiaNr0LmBkRG0sWrQVmSNpW408j4t48azUzs47LNUTSmzbuW9Y2tWx+OsmzS0rblgIj86zNzMw6z79YNzOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLDOHiJmZZeYQMTOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLDOHiJmZZZZbiEg6VNLjJa8Nki4vG1MvaX3JmC+U9J0qabGkJZKuyqtOMzPLLrcnG0bEYmAUgKQ+wCpgRgtDH4qISaUN6fibSB6tuxKYI+nuiFiUV71mZtZxlTqcNQH4R0Qsb+f4scCSiFgaEVuA24HJuVVnZmaZ5PqM9RJTgNta6Rsv6S/AauCKiFgIDAaeKRmzEjimpYUlNQANALW1tRQKha6q2cw6oVgs+vuY6s3bIvcQkdQfeCfwmRa65wFviIiipNOBXwLDAbUwNlpaf0RMA6YB1NXVRX19fVeUbWadVCgU8Pcx0Zu3RSUOZ50GzIuIf5Z3RMSGiCim0/cA/STtR7LncVDJ0CEkeypmZlZFKhEiZ9PKoSxJB0pSOj02rWctMAcYLmlYuiczBbi7ArWamVkH5Ho4S9IAkiusLi5puwQgIqYC7wU+IqkR2AxMiYgAGiVdBvwO6APcmp4rMTOzKpJriETEJmDfsrapJdM3Aje2suw9wD151mdmZp3jX6ybmVlmDhEzM8vMIWJmZpk5RMzMLDOHiJmZZeYQMTOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLDOHiJmZZeYQMTOzzBwiZmaWWW4hIulQSY+XvDZIurxszAckPZG+HpE0sqRvmaS/psvOzatOMzPLLreHUkXEYmAUgKQ+wCpgRtmwp4ETI+IFSacB04BjSvpPioh/5VWjmZl1Tq5PNiwxAfhHRCwvbYyIR0pmHwWGVKgeMzPrApUKkSnAbTsZ8yHgtyXzAcyUFMAtETGtpYUkNQANALW1tRQKhc5Xa2adViwW/X1M9eZtoYjI9w2k/sBq4IiI+GcrY04CvgMcHxFr07bXR8RqSQcA9wEfjYgH23qvurq6mDvXp0/MqkGhUKC+vr67y6gK1bwtJD0WEXVZl6/E1VmnAfPaCJARwHeBydsCBCAiVqd/nyc5lzK2ArWamVkHVCJEzqaVQ1mSDgbuAs6NiKdK2gdKGrRtGpgILKhArWZm1gG5nhORNAA4Gbi4pO0SgIiYCnwB2Bf4jiSAxnS3qhaYkbb1BX4aEffmWauZmXVcriESEZtIQqK0bWrJ9EXARS0stxQYWd5uZmbVxb9YNzOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLDOHiJmZZeYQMTOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLLPcQkTSoZIeL3ltkHR52RhJ+pakJZKekDS6pO9USYvTvqvyqtPMzLLL7aFUEbEYGAUgqQ+wiuRZ6aVOA4anr2OAm4Fj0vE3kTwVcSUwR9LdEbEor3rNzKzjKnU4awLwj4hYXtY+GfhhJB4F9pL0OmAssCQilkbEFuD2dGz7NTfDz34G118Pa9d2wUcwM7NylQqRKcBtLbQPBp4pmV+ZtrXW3n7r1sGvfw2zZ8P8+R2r1szM2iXXZ6wDSOoPvBP4TEvdLbRFG+0trb8BaACora2lUCj8u/PMM2HLlmS6tN3MclcsFnf8Pr6G9eZtkXuIkJz3mBcR/2yhbyVwUMn8EGA10L+V9leJiGnANIC6urqor6/vgpLNrLMKhQL+PiZ687aoxOGss2n5UBbA3cB56VVa44D1EfEsMAcYLmlYuiczJR1rZmZVJNc9EUkDSK6wurik7RKAiJgK3AOcDiwBNgEfTPsaJV0G/A7oA9waEQvzrNXMzDou1xCJiE3AvmVtU0umA7i0lWXvIQkZMzOrUv7FupmZZeYQMTOzzBwiZmaWmUPEzMwyc4iYmVlmSi6Q6h0krQHK789l/7YnsL67i2hDJevL6726ar2dWU9Hl81r/H7Avzqw3t6smrfFoRExKOvClfjFesVExP7dXUM1kzQtIhq6u47WVLK+vN6rq9bbmfV0dNm8xkuaGxF17V1vb1bN20LS3M4s78NZry3/r7sL2IlK1pfXe3XVejuzno4um/d468V61eEsM6se1fx/35VWzduis7V5T8TM8jKtuwuoItW8LTpVm/dEzMwsM++JmJlZZg4RMzPLzCFiZplIulXS85IWlLTtI+k+SX9P/+7dnTVWiqSDJN0v6UlJCyX9V9re7dtD0m6S/izpL2ltX+zK2hwiZpbVdODUsrargD9ExHDgD+n8a0Ej8MmIOAwYB1wq6XCqY3u8ArwtIkYCo4BT04cAdkltDhEzyyQiHgTWlTVPBn6QTv8AOBNA0ick3ZpOHyVpQfrQul4hIp6NiHnp9EvAk8BgqmB7RKKYzvZLX9FVtTlEzKwr1aaPuCb9e0DafgNwiKR3Ad8HLk4fWtfrSBoK/AcwmyrZHpL6SHoceB64LyK6rDaHiJnlLiKagQuAHwEPRMTD3VtRPiTtDvwCuDwiNrQ2rtLbIyKaImIUMAQYK+nIrqrNIWJmXemfkl4HkP59vqRvOFAEXt8dheVNUj+SAPlJRNyVNlfV9oiIF4ECybmsLqnNIWJmXelu4Px0+nzgVwCS9gS+CZwA7Cvpvd1TXj4kCfge8GREfKOkq9u3h6T9Je2VTtcAbwf+1lW1+RfrZpaJpNuAepLbnP8TuBr4JXAHcDCwAnhfRKxLT9Q+HhHfknQQcD9wbEQ83+LKexhJxwMPAX8FmtPmz5KcF+nW7SFpBMmJ8z4kOw53RMR/S9q3K2pziJiZWWY+nGVmZpk5RMzMLDOHiJmZZeYQMTOzzBwiZmaWmUPErA3p3VmflrRPOr93Ov+GFsYWX72GVtd7jaQrOlhLu9dvVikOEbM2RMQzwM3AdWnTdcC0iFjefVWZVQ+HiNnO/S8wTtLlwPHA19u7oKQzJM2WNF/S7yXVlnSPlPTH9HkOHy5Z5kpJcyQ9se3ZD2bVqm93F2BW7SJiq6QrgXuBiRGxpQOL/wkYFxEh6SLgU8An074RJM+eGAjMl/Qb4EiS+xaNBQTcLemE9LbrZlXHIWLWPqcBz5L8R/6+Diw3BPhZeoO7/sDTJX2/iojNwGZJ95MEx/HARGB+OmZ3klBxiFhV8uEss52QNAo4mWSv4ePb7nzaTt8GboyIo4CLgd1K+srvORQkex//NyJGpa9DIuJ7nSjfLFcOEbM2pHdnvZnk+RArgK8B13dgFXsCq9Lp88v6JqfPv96X5EaGc4DfARemz6VA0mBJB2BWpXw4y6xtHwZWRMS2Q1jfAS6QdGJEPFA2doCklSXz3wCuAX4uaRXwKDCspP/PwG9I7qJ6bUSsBlZLOgyYleQXReAcdnzWg1nV8F18zcwsMx/OMjOzzBwiZmaWmUPEzMwyc4iYmVlmDhEzM8vMIWJmZpk5RMzMLLP/Dxhg608AqsBvAAAAAElFTkSuQmCC\n" - ], - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# matplotlib\n", - "import matplotlib.pyplot as plt\n", - "plt.scatter([1,2,3], [7,8,9], s=[3,60,90], c=['red','blue','green'], alpha=0.5)\n", - "\n", - "plt.text(10, 8.5, \"Here is some\")\n", - "\n", - "plt.grid(True)\n", - "\n", - "plt.xscale('log') \n", - "plt.xlabel(\"X Label\")\n", - "plt.ylabel(\"Y Label\")\n", - "plt.title(\"Title\")\n", - "plt.xticks([10,20,30], [\"10x\", \"20x\",\"30x\"])\n", - "plt.show()" - ] - } - ], - "metadata": { - "authors": [ - { - "name": "Morteza Ansarinia" - } - ], - "description": "Some random codes to learn/train/remember pandas :-)\n", - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - }, - "pycharm": { - "stem_cell": { - "cell_type": "raw", - "metadata": { - "collapsed": false - }, - "source": [ - "Simulate \n" - ] - } - }, - "tags": [ - "pandas", - "playground" - ], - "title": "Pandas Playground" - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/py/poisson_generator.py b/py/poisson_generator.py deleted file mode 100644 index f800cfd..0000000 --- a/py/poisson_generator.py +++ /dev/null @@ -1,76 +0,0 @@ -#%% -import random -from math import log -import matplotlib.pyplot as plt -import numpy as np - -class PoissonProcess(): - def __init__(self, **kwargs): - self.lam = kwargs.get("lam", 5) # rate - self.size = kwargs.get("size", 100) - - def generate(self): - _time = 0 - events = [] - for i in range(self.size): - p = random.random() - - _interval = - log(1-p) / self.lam - _time = _time + _interval - - events.append(_time) - return events - -#1 (events) -poi = PoissonProcess(lam = 5).generate() -print(poi) - -#matplotlib: x=index, y=poi[index] -plt.eventplot(poi) - - -#2 (points) -poi = np.random.poisson(lam=5,size=100) -print(f"avergae is {np.average(poi)}") - -#poi = [i-j for i,j in zip(poi[:-1],poi[1:])] - -poi2 = [np.sum(poi[1:i]) for i in range(len(poi))] -# or poin2=np.cumsum(poi) -print(poi2) -#poi = np.diff(poi) # alternative numpy solution for inter-interval durations -#plt.plot(poi2) - -plt.show() -#%% - -import numpy as np -from scipy.special import factorial - -def events_prob(events_per_unit_time, total_time, num_of_events): - # poisson dist - lam = events_per_unit_time * total_time - return np.exp(-lam) * np.power(lam, num_of_events) * factorial(num_of_events) - - -rate = 5 -ks = np.arange(20) -ps = events_prob(5,20,ks) -print(np.argmax(ps), np.max(ps)) - -#%% - - -# %% -# Using numpy exp to generate random interarrivals - -import numpy as np - -duration = 20 -rate = 5 -size = 2 * rate * duration - -inter_arrivals = np.random.exponential(scale = 1/rate, size=size) -arrivals = np.cumsum(inter_arrivals) - -spikes = arrivals[np.where(arrivals