Datasets:

anujsahani01
/

TextCodeDepot

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 16k rows

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.

Unnamed: 0 int64 0 16k	text_prompt stringlengths 110 62.1k	code_prompt stringlengths 37 152k
12,400	Given the following text description, write Python code to implement the functionality described below step by step Description: Using subset-selector Create SubsetSelector with data and plot. y should be a multidimensional array. Each sample from a subset of y is graphed. You can scroll through subsets using the figure's toolbar, select graphs of interest, and get the data back from them later. Execute the cell below and click on some graphs to try it out. Step1: Using saved data	Python Code: from subset_selector import SubsetSelector ss = SubsetSelector(x, y) ss.plot() Explanation: Using subset-selector Create SubsetSelector with data and plot. y should be a multidimensional array. Each sample from a subset of y is graphed. You can scroll through subsets using the figure's toolbar, select graphs of interest, and get the data back from them later. Execute the cell below and click on some graphs to try it out. End of explanation saved_data = ss.get_ydata() figure, _ = plt.subplots(1, 2, figsize=(12, 2)) for data, ax in zip(saved_data, figure.get_axes()): ax.plot(x, data) Explanation: Using saved data End of explanation
12,401	Given the following text description, write Python code to implement the functionality described below step by step Description: Copyright 2020 The TensorFlow Authors. Step1: Keras でマスキングとパディングをする <table class="tfo-notebook-buttons" align="left"> <td><a target="_blank" href="https Step2: はじめにマスキングは、シーケンス処理レイヤーに入力の特定の時間ステップが欠落しているためデータを処理する際にスキップする必要があることを伝えるために使用する手法です。パディングは、マスキングされたステップがシーケンスの先頭または末尾にある特殊なマスキングです。パディングは、シーケンスデータを連続したバッチにエンコードする必要性から生まれました。バッチ内のすべてのシーケンスを所定の標準の長さに合わせるためには、一部のシーケンスをパディングまたはトランケートする（切り詰める）必要があるためです。では、詳しく見ていきましょう。パディングシーケンスデータシーケンスデータを処理する際に個々のサンプルの長さが異なることは、非常に一般的です。次の例（単語としてトークン化されたテキスト）を考えてみます。 [ ["Hello", "world", "!"], ["How", "are", "you", "doing", "today"], ["The", "weather", "will", "be", "nice", "tomorrow"], ] 語彙検索の後、データは以下のように整数としてベクトル化されるかもしれません。 [ [71, 1331, 4231] [73, 8, 3215, 55, 927], [83, 91, 1, 645, 1253, 927], ] データは、個々のサンプルがそれぞれ 3、5、6 の長さを持つネストされたリストです。ディープラーニングモデルの入力データは，単一のテンソル（例えばこの場合だと(batch_size, 6, vocab_size)のような形状）でなければならないため、最長のアイテムよりも短いサンプルは、何らかのプレースホルダー値でパディングする必要があります。（その代わりに、短いサンプルをパディングする前に長いサンプルをトランケートすることも可能です。） Keras は Python のリストを共通の長さにトランケートしたりパディングしたりするユーティリティ関数を提供します：tf.keras.preprocessing.sequence.pad_sequences Step3: マスキング全てのサンプルが統一された長さになったので、今度はデータの一部が実際にパディングされ、無視されるべきであることをモデルに知らせなければなりません。このメカニズムがマスキングです。 Keras モデルで入力マスクを導入するには、3 つの方法があります。 keras.layers.Masking レイヤーを追加する。 keras.layers.Embedding レイヤーを mask_zero=True で設定する。 mask引数をサポートするレイヤー（RNN レイヤーなど）を呼び出す際に、この引数を手動で渡す。マスク生成レイヤー Step4: 出力された結果から分かるように、マスクは形状が(batch_size, sequence_length)の 2 次元ブールテンソルであり、そこでは個々の False エントリは、対応する時間ステップを処理中に無視すべきであることを示しています。 Functional API と Sequential API のマスク伝播 Functional API または Sequential API を使用する場合、Embedding レイヤーまたは Masking レイヤーによって生成されたマスクは、それらを使用できる任意のレイヤー（例えば RNN レイヤーなど）にネットワークを介して伝播されます。Keras は入力に対応するマスクを自動的に取得し、その使用方法を知っている任意のレイヤーに渡します。例えば、以下の Sequential API モデルでは、LSTM レイヤーは自動的にマスクを取得します。つまりこれは、パディングされた値を無視するということです。 Step5: これは、以下の Functional API モデルでも同様です。 Step6: マスクテンソルを直接レイヤーに渡すマスクを扱うことができるレイヤー（LSTM レイヤーなど）は、それらの __call__ メソッドに mask 引数を持っています。一方、マスクを生成するレイヤー（例えば <br> Embedding）は、呼び出し可能な compute_mask(input, previous_mask) メソッドを公開します。例えば下記のようにして、マスクを生成するレイヤーの compute_mask() メソッドの出力を、マスクを消費するレイヤーの __call__ メソッドに渡すことができます。 Step8: カスタムレイヤーでマスキングをサポートする場合によっては、マスクを生成するレイヤー（Embedding など）や、現在のマスクを変更するレイヤーを書く必要があります。例えば、時間次元で連結する Concatenate レイヤーのように、入力とは異なる時間次元を持つテンソルを生成するレイヤーは、現在のマスクを変更して、マスクされた時間ステップを下流のレイヤーが適切に考慮に入れられるようにする必要があります。これを行うには、レイヤーに layer.compute_mask() メソッドを実装します。これは、入力と現在のマスクが与えられた時に新しいマスクを生成します。ここでは、現在のマスクを変更する必要がある TemporalSplit レイヤーの例を示します。 Step9: もう 1 つの例として、入力値からマスクを生成できる CustomEmbedding レイヤーの例を示します。 Step10: オプトインして互換性のあるレイヤー間でマスクを伝播するほとんどのレイヤーは時間次元を変更しないため、現在のマスクを変更する必要はありません。しかし、現在のマスクを変更せずにそれらを次のレイヤーに伝播したい場合があります。これはオプトイン動作です。デフォルトでは、（フレームワークがマスクの伝播が安全かどうか判断する方法を持たないため）カスタムレイヤーは現在のマスクを破棄します。時間次元を変更しないカスタムレイヤーを持ち、それが現在の入力マスクを伝播できるようにしたい場合は、レイヤーのコンストラクタを self.supports_masking = True に設定する必要があります。この場合、compute_mask() のデフォルトの動作は、現在のマスクを通過させるだけとなります。マスク伝搬のためにホワイトリスト化されたレイヤーの例を示します。 Step11: これで、マスク生成レイヤー（Embedding など）とマスク消費レイヤー（LSTM など）間でこのカスタムレイヤーの使用が可能となり、マスク消費レイヤーまで届くようにマスクを渡します。 Step12: マスク情報が必要なレイヤーを書く一部のレイヤーはマスクコンシューマです。それらは call で mask 引数を受け取り、それを使って特定の時間ステップをスキップするかどうかを判断します。そのようなレイヤーを書くには、単純に call シグネチャに mask=None 引数を追加します。入力に関連付けられたマスクは、それが利用可能な時にいつでもレイヤーに渡されます。以下に簡単な例を示します。これは入力シーケンスの時間次元（軸 1）のソフトマックスを計算し、マスクされたタイムステップを破棄するレイヤーです。	Python Code: #@title Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. Explanation: Copyright 2020 The TensorFlow Authors. End of explanation import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Explanation: Keras でマスキングとパディングをする <table class="tfo-notebook-buttons" align="left"> <td><a target="_blank" href="https://www.tensorflow.org/guide/keras/masking_and_padding"><img src="https://www.tensorflow.org/images/tf_logo_32px.png"> TensorFlow.orgで表示</a></td> <td><a target="_blank" href="https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ja/guide/keras/masking_and_padding.ipynb"><img src="https://www.tensorflow.org/images/colab_logo_32px.png"> Google Colab で実行</a></td> <td><a target="_blank" href="https://github.com/tensorflow/docs-l10n/blob/master/site/ja/guide/keras/masking_and_padding.ipynb"><img src="https://www.tensorflow.org/images/GitHub-Mark-32px.png">GitHub でソースを表示</a></td> <td><a href="https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ja/guide/keras/masking_and_padding.ipynb"><img src="https://www.tensorflow.org/images/download_logo_32px.png">ノートブックをダウンロード/a0}</a></td> </table> Setup End of explanation raw_inputs = [ [711, 632, 71], [73, 8, 3215, 55, 927], [83, 91, 1, 645, 1253, 927], ] # By default, this will pad using 0s; it is configurable via the # "value" parameter. # Note that you could "pre" padding (at the beginning) or # "post" padding (at the end). # We recommend using "post" padding when working with RNN layers # (in order to be able to use the # CuDNN implementation of the layers). padded_inputs = tf.keras.preprocessing.sequence.pad_sequences( raw_inputs, padding="post" ) print(padded_inputs) Explanation: はじめにマスキングは、シーケンス処理レイヤーに入力の特定の時間ステップが欠落しているためデータを処理する際にスキップする必要があることを伝えるために使用する手法です。パディングは、マスキングされたステップがシーケンスの先頭または末尾にある特殊なマスキングです。パディングは、シーケンスデータを連続したバッチにエンコードする必要性から生まれました。バッチ内のすべてのシーケンスを所定の標準の長さに合わせるためには、一部のシーケンスをパディングまたはトランケートする（切り詰める）必要があるためです。では、詳しく見ていきましょう。パディングシーケンスデータシーケンスデータを処理する際に個々のサンプルの長さが異なることは、非常に一般的です。次の例（単語としてトークン化されたテキスト）を考えてみます。 [ ["Hello", "world", "!"], ["How", "are", "you", "doing", "today"], ["The", "weather", "will", "be", "nice", "tomorrow"], ] 語彙検索の後、データは以下のように整数としてベクトル化されるかもしれません。 [ [71, 1331, 4231] [73, 8, 3215, 55, 927], [83, 91, 1, 645, 1253, 927], ] データは、個々のサンプルがそれぞれ 3、5、6 の長さを持つネストされたリストです。ディープラーニングモデルの入力データは，単一のテンソル（例えばこの場合だと(batch_size, 6, vocab_size)のような形状）でなければならないため、最長のアイテムよりも短いサンプルは、何らかのプレースホルダー値でパディングする必要があります。（その代わりに、短いサンプルをパディングする前に長いサンプルをトランケートすることも可能です。） Keras は Python のリストを共通の長さにトランケートしたりパディングしたりするユーティリティ関数を提供します：tf.keras.preprocessing.sequence.pad_sequences End of explanation embedding = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True) masked_output = embedding(padded_inputs) print(masked_output._keras_mask) masking_layer = layers.Masking() # Simulate the embedding lookup by expanding the 2D input to 3D, # with embedding dimension of 10. unmasked_embedding = tf.cast( tf.tile(tf.expand_dims(padded_inputs, axis=-1), [1, 1, 10]), tf.float32 ) masked_embedding = masking_layer(unmasked_embedding) print(masked_embedding._keras_mask) Explanation: マスキング全てのサンプルが統一された長さになったので、今度はデータの一部が実際にパディングされ、無視されるべきであることをモデルに知らせなければなりません。このメカニズムがマスキングです。 Keras モデルで入力マスクを導入するには、3 つの方法があります。 keras.layers.Masking レイヤーを追加する。 keras.layers.Embedding レイヤーを mask_zero=True で設定する。 mask引数をサポートするレイヤー（RNN レイヤーなど）を呼び出す際に、この引数を手動で渡す。マスク生成レイヤー : Embedding と Masking 内部でこれらのレイヤーはマスクテンソル（形状(batch, sequence_length)の 2 次元テンソル）を作成し、Masking または Embedding レイヤーによって返されるテンソル出力にアタッチします。 End of explanation model = keras.Sequential( [layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True), layers.LSTM(32),] ) Explanation: 出力された結果から分かるように、マスクは形状が(batch_size, sequence_length)の 2 次元ブールテンソルであり、そこでは個々の False エントリは、対応する時間ステップを処理中に無視すべきであることを示しています。 Functional API と Sequential API のマスク伝播 Functional API または Sequential API を使用する場合、Embedding レイヤーまたは Masking レイヤーによって生成されたマスクは、それらを使用できる任意のレイヤー（例えば RNN レイヤーなど）にネットワークを介して伝播されます。Keras は入力に対応するマスクを自動的に取得し、その使用方法を知っている任意のレイヤーに渡します。例えば、以下の Sequential API モデルでは、LSTM レイヤーは自動的にマスクを取得します。つまりこれは、パディングされた値を無視するということです。 End of explanation inputs = keras.Input(shape=(None,), dtype="int32") x = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)(inputs) outputs = layers.LSTM(32)(x) model = keras.Model(inputs, outputs) Explanation: これは、以下の Functional API モデルでも同様です。 End of explanation class MyLayer(layers.Layer): def __init__(self, kwargs): super(MyLayer, self).__init__(kwargs) self.embedding = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True) self.lstm = layers.LSTM(32) def call(self, inputs): x = self.embedding(inputs) # Note that you could also prepare a `mask` tensor manually. # It only needs to be a boolean tensor # with the right shape, i.e. (batch_size, timesteps). mask = self.embedding.compute_mask(inputs) output = self.lstm(x, mask=mask) # The layer will ignore the masked values return output layer = MyLayer() x = np.random.random((32, 10)) * 100 x = x.astype("int32") layer(x) Explanation: マスクテンソルを直接レイヤーに渡すマスクを扱うことができるレイヤー（LSTM レイヤーなど）は、それらの __call__ メソッドに mask 引数を持っています。一方、マスクを生成するレイヤー（例えば <br> Embedding）は、呼び出し可能な compute_mask(input, previous_mask) メソッドを公開します。例えば下記のようにして、マスクを生成するレイヤーの compute_mask() メソッドの出力を、マスクを消費するレイヤーの __call__ メソッドに渡すことができます。 End of explanation class TemporalSplit(keras.layers.Layer): Split the input tensor into 2 tensors along the time dimension. def call(self, inputs): # Expect the input to be 3D and mask to be 2D, split the input tensor into 2 # subtensors along the time axis (axis 1). return tf.split(inputs, 2, axis=1) def compute_mask(self, inputs, mask=None): # Also split the mask into 2 if it presents. if mask is None: return None return tf.split(mask, 2, axis=1) first_half, second_half = TemporalSplit()(masked_embedding) print(first_half._keras_mask) print(second_half._keras_mask) Explanation: カスタムレイヤーでマスキングをサポートする場合によっては、マスクを生成するレイヤー（Embedding など）や、現在のマスクを変更するレイヤーを書く必要があります。例えば、時間次元で連結する Concatenate レイヤーのように、入力とは異なる時間次元を持つテンソルを生成するレイヤーは、現在のマスクを変更して、マスクされた時間ステップを下流のレイヤーが適切に考慮に入れられるようにする必要があります。これを行うには、レイヤーに layer.compute_mask() メソッドを実装します。これは、入力と現在のマスクが与えられた時に新しいマスクを生成します。ここでは、現在のマスクを変更する必要がある TemporalSplit レイヤーの例を示します。 End of explanation class CustomEmbedding(keras.layers.Layer): def __init__(self, input_dim, output_dim, mask_zero=False, kwargs): super(CustomEmbedding, self).__init__(kwargs) self.input_dim = input_dim self.output_dim = output_dim self.mask_zero = mask_zero def build(self, input_shape): self.embeddings = self.add_weight( shape=(self.input_dim, self.output_dim), initializer="random_normal", dtype="float32", ) def call(self, inputs): return tf.nn.embedding_lookup(self.embeddings, inputs) def compute_mask(self, inputs, mask=None): if not self.mask_zero: return None return tf.not_equal(inputs, 0) layer = CustomEmbedding(10, 32, mask_zero=True) x = np.random.random((3, 10)) * 9 x = x.astype("int32") y = layer(x) mask = layer.compute_mask(x) print(mask) Explanation: もう 1 つの例として、入力値からマスクを生成できる CustomEmbedding レイヤーの例を示します。 End of explanation class MyActivation(keras.layers.Layer): def __init__(self, kwargs): super(MyActivation, self).__init__(kwargs) # Signal that the layer is safe for mask propagation self.supports_masking = True def call(self, inputs): return tf.nn.relu(inputs) Explanation: オプトインして互換性のあるレイヤー間でマスクを伝播するほとんどのレイヤーは時間次元を変更しないため、現在のマスクを変更する必要はありません。しかし、現在のマスクを変更せずにそれらを次のレイヤーに伝播したい場合があります。これはオプトイン動作です。デフォルトでは、（フレームワークがマスクの伝播が安全かどうか判断する方法を持たないため）カスタムレイヤーは現在のマスクを破棄します。時間次元を変更しないカスタムレイヤーを持ち、それが現在の入力マスクを伝播できるようにしたい場合は、レイヤーのコンストラクタを self.supports_masking = True に設定する必要があります。この場合、compute_mask() のデフォルトの動作は、現在のマスクを通過させるだけとなります。マスク伝搬のためにホワイトリスト化されたレイヤーの例を示します。: End of explanation inputs = keras.Input(shape=(None,), dtype="int32") x = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)(inputs) x = MyActivation()(x) # Will pass the mask along print("Mask found:", x._keras_mask) outputs = layers.LSTM(32)(x) # Will receive the mask model = keras.Model(inputs, outputs) Explanation: これで、マスク生成レイヤー（Embedding など）とマスク消費レイヤー（LSTM など）間でこのカスタムレイヤーの使用が可能となり、マスク消費レイヤーまで届くようにマスクを渡します。 End of explanation class TemporalSoftmax(keras.layers.Layer): def call(self, inputs, mask=None): broadcast_float_mask = tf.expand_dims(tf.cast(mask, "float32"), -1) inputs_exp = tf.exp(inputs) * broadcast_float_mask inputs_sum = tf.reduce_sum( inputs_exp * broadcast_float_mask, axis=-1, keepdims=True ) return inputs_exp / inputs_sum inputs = keras.Input(shape=(None,), dtype="int32") x = layers.Embedding(input_dim=10, output_dim=32, mask_zero=True)(inputs) x = layers.Dense(1)(x) outputs = TemporalSoftmax()(x) model = keras.Model(inputs, outputs) y = model(np.random.randint(0, 10, size=(32, 100)), np.random.random((32, 100, 1))) Explanation: マスク情報が必要なレイヤーを書く一部のレイヤーはマスクコンシューマです。それらは call で mask 引数を受け取り、それを使って特定の時間ステップをスキップするかどうかを判断します。そのようなレイヤーを書くには、単純に call シグネチャに mask=None 引数を追加します。入力に関連付けられたマスクは、それが利用可能な時にいつでもレイヤーに渡されます。以下に簡単な例を示します。これは入力シーケンスの時間次元（軸 1）のソフトマックスを計算し、マスクされたタイムステップを破棄するレイヤーです。 End of explanation
12,402	Given the following text description, write Python code to implement the functionality described below step by step Description: See quick reference at the bottom See full module reference section for full details In the begining of each analysis, the first step is to load ReproPhylo and its dependencies with the command Step1: Once this is done we can start a Project. A Project contains all the data, metadata, methods and environment information, and it is the unit that is saved as a pickle file, which is version controled with <a href=http Step2: This is a single Locus description (a Locus object). We can confirm its content by printing it like this Step3: Describing loci using a file Another way of describing loci is to write them in a file. The file has one line for each Locus, where each line has at least four items, separated by commas. The items, as above, are the character type, the feature type, the name of the locus and other possible aliases. At least one alias must be specified, but it can be identical to the name. For the MT-CO1 Locus, a file would look like this Step4: The command generated the loci file and wrote it in data/loci.csv. Here are some excerpts separated by three dots Step5: Regardless of whether we have one or more Locus objects, they are read as a list, which means that they are wrapped with square brackets and separated by comma Step6: This command will start the Project and will write it to the pickle file outputs/dummy.pkpj Step7: This will provoke a bunch of Git related messages which will be discussed in the version control section of this tutorial. If we print the Project we'll get this massage Step8: 3.2.3 Modifying the loci of an existing Project As you have seen, when you start a Project you pass a list of loci or a csv file name with the loci attributes Step9: 3.2.4 Quick reference	Python Code: from reprophylo import * Explanation: See quick reference at the bottom See full module reference section for full details In the begining of each analysis, the first step is to load ReproPhylo and its dependencies with the command End of explanation coi = Locus(char_type='dna', feature_type='CDS', name='MT-CO1', aliases=['cox1', 'coi']) Explanation: Once this is done we can start a Project. A Project contains all the data, metadata, methods and environment information, and it is the unit that is saved as a pickle file, which is version controled with <a href=http://en.wikipedia.org/wiki/Git_(software)>Git</a>. Although ReproPhylo is designed to record versions and update the pickle file automatically, this will be opt-out of in this tutorial, and will be introduced after we have covered the basics. Instead, we will manually save a pickle file at the end of each section, and will load it in the next one. You should use the same pickle file name at the end of all the sections. The new content will be added to the one already present in the file. If you want to jump ahead, there are presaved pickle files (Tutorial_files/basic/outputs), numbered according to the section after which they were saved. For example, outputs/3.6.alignments.pkpj was saved at the end of section 3.6 and can be loaded at the top of section 3.7, instead of your own file. To start a Project, we have to specify the loci to analyse (not actual sequence data, only some information on the loci) and a pickle file name. 3.2.1 Describing Loci A Locus can be described manually using a command or by providing a file. For each Locus, we have to specify the character type (DNA or protein) the feature type (eg, rRNA, CDS or gene), the name of the locus (eg, MT-CO1) and other possible aliases which may come handy if we want to read a genbank file (eg, cox1, coi). Describe loci using a command End of explanation print coi Explanation: This is a single Locus description (a Locus object). We can confirm its content by printing it like this: End of explanation list_loci_in_genbank('data/Tetillidae.gb', # The input genbank # file 'data/loci.csv', # The loci file 'outputs/loci_counts.txt') # Additional # output, # discussed # below. Explanation: Describing loci using a file Another way of describing loci is to write them in a file. The file has one line for each Locus, where each line has at least four items, separated by commas. The items, as above, are the character type, the feature type, the name of the locus and other possible aliases. At least one alias must be specified, but it can be identical to the name. For the MT-CO1 Locus, a file would look like this: dna,CDS,MT-CO1,cox1,coi Deducing a loci file from a genbank file A third way of describing loci is to run a command that guesses them from a genbank file and writes them into a comma delimited file, as above. This file can be used as is, or it can be edited. The following command will prepare such a loci file from a genbank file containing all the GenBank records belonging to the sponge family Tetillidae. Text starting with a hash (#) is a comment which do not affect the command: End of explanation ssu = Locus('dna','rRNA','18S',['ssu','SSU-rRNA']) Explanation: The command generated the loci file and wrote it in data/loci.csv. Here are some excerpts separated by three dots: <pre> dna,rRNA,18s,18S ribosomal RNA,18S rRNA dna,rRNA,28s,28S large subunit ribosomal RNA,28S ribosomal RNA ... dna,CDS,MT-ATP8,atp8,ATP8 dna,CDS,MT-CO1,coi,COI,cox1,COX1,coxI ... dna,rRNA,rnl,rnl dna,rRNA,rns,rns dna,rRNA,rrnL,rrnL </pre> Each line represents a locus that was found in the genbank file data/Tetillidae.gb. For some genes, such as 18s, synonyms were recognized and placed as aliases in one line. In other cases, such as for rnl and rrnL, they were not. Editing the loci file Possible edits to this file include: Synonymization. This is done by adding a comma and a shared integer in all the lines that are the same locus. For example the lines        dna,rRNA,rnl,rnl        dna,rRNA,rrnL,rrnL        will become        dna,rRNA,rnl,rnl,9        dna,rRNA,rrnL,rrnL,9        Which integer is written is unimportant, as long as it is shared between synonymous lines. Change of character type. If our data includes translations to protein sequence, we can change dna to prot, as such:        prot,CDS,MT-CO1,coi,COI,cox1,COX1,coxI.        This will tell the program to use protein sequences instead of DNA sequence. The sequence alignment tutorial explains how to use both protein and DNA sequence of the same locus to conduct codon alignment. Deletion of loci. It is possible to delete loci we do not want to analyse. They will not be read, even if they exit in our data. The second file that the command above produced, the outputs/loci_counts.txt, contains a list of the loci found in the genbank file, with the number of their occurances. This can be used as a guide when desciding which loci to delete and which to keep. 3.2.2 Loading loci to a new Project Loading Locus objects First we'll make another Locus object to make a point that more than one can be read: End of explanation loci_list = [coi, ssu] Explanation: Regardless of whether we have one or more Locus objects, they are read as a list, which means that they are wrapped with square brackets and separated by comma: End of explanation pj = Project('data/edited_loci.csv', pickle='outputs/my_project.pkpj', git=False) Explanation: This command will start the Project and will write it to the pickle file outputs/dummy.pkpj: <pre> pj = Project(loci_list, pickle='outputs/dummy.pkpj') </pre> This following alternative will start a Project and will load the loci from a file data/edited_loci.csv that looks like this: <pre> dna,rRNA,18s,18S ribosomal RNA,18S rRNA dna,rRNA,28s,28S large subunit ribosomal RNA dna,CDS,MT-CO1,coi,COI,cox1,COX1,coxI </pre> End of explanation print pj Explanation: This will provoke a bunch of Git related messages which will be discussed in the version control section of this tutorial. If we print the Project we'll get this massage: End of explanation # Update the pickle file pickle_pj(pj, 'outputs/my_project.pkpj') Explanation: 3.2.3 Modifying the loci of an existing Project As you have seen, when you start a Project you pass a list of loci or a csv file name with the loci attributes: pj = Project(loci_list, pickle='filename') Once the Project exists, it is possible to modify the Locus objects it contains. To add a Locus, you need to create it, as you have done: lsu = Locus('dna', 'rRNA', '28S', ['28s','LSU-rRNA']) and then also add it to the Project. Loci are stored in a list called pj.loci. So the new Locus can be appended to it: pj.loci.append(ssu) or if we have a list of new loci to add, for example: new_loci_list = [nd5, lsu] it can be added to the loci list like so: pj.loci += new_loci_list Lastly, we can modify loci that are already in pj.loci. For example, change the name and add an alias to the MT-CO1 Locus object: <pre> for l in pj.loci: # Find the Locus named MT-CO1 if l.name == 'MT-CO1': l.name = 'COI' # Rename it to COI l.aliases.append('coi') # Add the alias coi </pre> End of explanation # A Locus object coi = Locus(char_type='dna', # or 'prot' feature_type='CDS', # any string name='MT-CO1', # any string aliases=['coi', 'cox1']) # list of strings # Guess loci.csv file from a genbank file list_loci_in_genbank('genbank.gb', 'loci.csv', 'loci_counts.txt') # Start a Project # With a Locus object list pj = Project([coi, ssu], pickle='pickle_filename') # With a loci.csv file pj = Project('loci.csv', pickle='pickle_filename') # Add a Locus to an existing Project pj.loci.append(coi) #Or pj.loci += [coi] # Modify a Locus existing in a Project for l in pj.loci: if l.name == 'MT-CO1': l.name = 'newName' l.feature_type = 'newFeatureType' l.char_type = 'prot' l.aliases.append('newAlias') #Or l.aliases += ['newAlias1,newAlias2'] Explanation: 3.2.4 Quick reference End of explanation
12,403	Given the following text description, write Python code to implement the functionality described below step by step Description: Chapter 3 Step1: if ... else statement python if <condition> Step2: if ...elif ... else statement python if <condition> Step3: Imagine that in the above program, 23 is the temperature which was read by some sensor or manually entered by the user and Normal is the response of the program. Step4: One line if There are instances where we might need to have If the code block is composed of only one line, it can be written after the colon	Python Code: password = input("Please enter the password:") if password == "Simsim": print("\t> Welcome to the cave") x = "Mayank" y = "TEST" if y == "TEST": print(x) if y: print("Hello World") z = None if z: print("TEST") x = 11 if x > 10: print("Hello") if x > 10.999999999999: print("Hello again") if x % 2 == 0: print("Bye bye bye ...") x = 10 y = None z = "111" print(id(y)) if x: print("Hello in x") if y: print("Hello in Y") if z: print("Hello in Z") Explanation: Chapter 3: Compound statements Compound statements contain one or groups of other statements; they affect or control the execution of those other statements in some way. In general, they span multiple lines, but can be also be listed in a single line. The if, while and for statements implement traditional control flow constructs, whereas try specifies exception handlers and/or cleanup code for a group of statements, while the with statement allows the execution of initialization and finalization code around a block of code. Function and class definitions are also syntactically compound statements. They consists of one or more ‘clauses’. A clause consists of a 'header' and a ‘suite’. The 'clause' headers of a particular compound statement are all at the same indentation level. They should begins with an uniquely identifying keyword and should ends with a colon. 'suite' is a group of statements controlled by a clause. It can be of one or more semicolon-separated simple statements on the same line as the header, following the header’s colon (one liner), or it can be one or more indented statements on subsequent lines. Only the latter form of a suite can contain nested compound statements; the following is illegal, mostly because it wouldn’t be clear to which if clause a following else clause would belong: Traditional Control Flow Constructs if Statement The if statement is used for conditional execution similar to that in most common languages. If statement can be constructed in three format depending on our need. if: when we have "if something do something" condition if .. else: when we have condition like "if something: do something else do something else" if .. elif ..else: When we have too many conditions or nested conditions if This format is used when specific operation needs to be performed if a specific condition is met. Syntax: python if <condition>: <code block> Where: <condition>: sentence that can be evaluated as true or false. <code block>: sequence of command lines. The clauses elif and else are optional and several elifs for the if may be used but only one else at the end. Parentheses are only required to avoid ambiguity. Example: End of explanation x = "Anuja" if x == "mayank": print("Name is mayank") else: print("Name is not mayank and its", x) Explanation: if ... else statement python if <condition>: <code block> else: <code block> Where: <condition>: sentence that can be evaluated as true if statement if statemente or false. <code block>: sequence of command lines. The clauses elif and else are optional and several elifs for the if may be used but only one else at the end. Parentheses are only required to avoid ambiguity. End of explanation # temperature value used to test temp = 31 if temp < 0: print ('Freezing...') elif 0 <= temp <= 20: print ('Cold') elif 21 <= temp <= 25: print ('Room Temprature') elif 26 <= temp <= 35: print ('Hot') else: print ('Its very HOT!, lets stay at home... \nand drink lemonade.') # temperature value used to test temp = 60 if temp < 0: print ('Freezing...') elif 0 <= temp <= 20: print ('Cold') elif 21 <= temp <= 25: print ('Room Temprature') elif 26 <= temp <= 35: print ('Hot') else: print ('Its very HOT!, lets stay at home... \nand drink lemonade.') Explanation: if ...elif ... else statement python if <condition>: <code block> elif <condition>: <code block> elif <condition>: <code block> else: <code block> Where: <condition>: sentence that can be evaluated as true or false. <code block>: sequence of command lines. The clauses elif and else are optional and several elifs for the if may be used but only one else at the end. Parentheses are only required to avoid ambiguity. End of explanation a = "apple" b = "banana" c = "Mango" if a == "apple": print("apple") elif b == "Mango": print("mango") elif c == "Mango": print("My Mango farm") Explanation: Imagine that in the above program, 23 is the temperature which was read by some sensor or manually entered by the user and Normal is the response of the program. End of explanation x = 20 if x > 10: print ("Hello ") print("-"*30) val = 1 if x < 10 else 24 print(val) Explanation: One line if There are instances where we might need to have If the code block is composed of only one line, it can be written after the colon: if temp < 0: print 'Freezing...' Since version 2.5, Python supports the expression: <variable> = <value 1> if <condition> else <value 2> Where <variable> receives <value 1> if <condition> is true and <value 2> otherwise. End of explanation
12,404	Given the following text description, write Python code to implement the functionality described below step by step Description: This IPython Notebook is for integrating filter curves with the spectra to show the Si gap's effect size on tranmission in IR imaging. Author Step1: From the Thorlabs website Step2: Normalize the transmission Step3: Drop wavelengths shorter than 1200 nm since they are absorbed. Step4: Construct a model. Step5: Plot the integrated flux for a variety of gap sizes. Define an integral function. Step6: Small gaps.	Python Code: %matplotlib inline import matplotlib.pyplot as plt import pandas as pd import numpy as np import seaborn as sns Explanation: This IPython Notebook is for integrating filter curves with the spectra to show the Si gap's effect size on tranmission in IR imaging. Author: Michael Gully-Santiago, [email protected] Date: April 16, 2015 First, let's see if we can get the filter curve data from say... Thorlabs. End of explanation fc = pd.read_excel("../data/FB1250-10.xlsx", sheetname='Transmission Data', parse_cols=[2,3,4], skipfooter=2) fc.tail() fc.columns Explanation: From the Thorlabs website: https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=1000 Read in the filter curve, fc End of explanation fc['wavelength'] = fc['Wavelength (nm)'] fc['transmission'] = fc['% Transmission']/fc['% Transmission'].max() Explanation: Normalize the transmission End of explanation fc.drop(fc.index[fc.wavelength < 1150], inplace=True) sns.set_context('notebook', font_scale=1.5) Explanation: Drop wavelengths shorter than 1200 nm since they are absorbed. End of explanation import etalon as etalon np.random.seed(78704) fc.wavelength.values n1 = etalon.sellmeier_Si(fc.wavelength.values) dsp = etalon.T_gap_Si_fast(fc.wavelength, 0.0, n1) sns.set_context('paper', font_scale=1.6) sns.set_style('ticks') model_absolute = etalon.T_gap_Si_fast(fc.wavelength, 50.0, n1) model = model_absolute/dsp plt.plot(fc.wavelength, model,label='50 nm gap spectrum') model_absolute = etalon.T_gap_Si_fast(fc.wavelength, 250.0, n1) model = model_absolute/dsp plt.plot(fc.wavelength, model,'--', label='250 nm gap spectrum') plt.fill_betweenx(fc.transmission, fc.wavelength, color='k',alpha=0.3) plt.text(1260, 0.5, 'FB1250-10', fontsize=14) #plt.plot(fc.wavelength, fc.transmission, '--',label='Filter Curve') plt.xlabel('$\lambda$ (nm)') plt.ylabel('T') plt.legend(loc='lower right') plt.xlim(1200, 1400) plt.savefig('../figs/F1250_10_filter.pdf') Explanation: Construct a model. End of explanation fc.transmission_norm = fc.transmission/fc.transmission.sum() integrate_flux = lambda x: (x * fc.transmission_norm).sum() Explanation: Plot the integrated flux for a variety of gap sizes. Define an integral function. End of explanation gap_sizes = np.arange(0, 50, 2) gap_trans = [integrate_flux(etalon.T_gap_Si_fast(fc.wavelength, gap_size, n1)/dsp) for gap_size in gap_sizes] sns.set_context('paper', font_scale=1.6) sns.set_style('ticks') plt.plot(gap_sizes, gap_trans, 's', label='Integrated transmission') plt.xlabel('Gap axial extent $d$ (nm)') plt.ylabel('FB1250-10 Transmission') plt.hlines(1.0, 0, 50, label='100% transmission') plt.hlines(0.998, 0, 50, linestyle='dashed', label = '99.8% transmission') plt.legend(loc='lower left') plt.savefig('../figs/FB1250-10_integ_trans.pdf') out_tbl = pd.DataFrame({'d (nm)':gap_sizes[::4], 'FB1250-10 Transmission':gap_trans[::4]}) out_tbl['FB1250-10 Transmission'] = out_tbl['FB1250-10 Transmission'].round(3) out_tbl = out_tbl[['d (nm)','FB1250-10 Transmission']] out_tbl out_tbl.to_latex('../tbls/tbl_FB1250_raw.tex', index=False) Explanation: Small gaps. End of explanation
12,405	Given the following text description, write Python code to implement the functionality described below step by step Description: Spark + Python = PySpark Esse notebook introduz os conceitos básicos do Spark através de sua interface com a linguagem Python. Como aplicação inicial faremos o clássico examplo de contador de palavras . Com esse exemplo é possível entender a lógica de programação funcional para as diversas tarefas de exploração de dados distribuídos. Para isso utilizaremos o livro texto Trabalhos completos de William Shakespeare obtidos do Projeto Gutenberg. Veremos que esse mesmo algoritmo pode ser empregado em textos de qualquer tamanho. Esse notebook contém Step2: (1b) Plural Vamos criar uma função que transforma uma palavra no plural adicionando uma letra 's' ao final da string. Em seguida vamos utilizar a função map() para aplicar a transformação em cada palavra do RDD. Em Python (e muitas outras linguagens) a concatenação de strings é custosa. Uma alternativa melhor é criar uma nova string utilizando str.format(). Nota Step3: (1c) Aplicando a função ao RDD Transforme cada palavra do nosso RDD em plural usando map() Em seguida, utilizaremos o comando collect() que retorna a RDD como uma lista do Python. Step4: Nota Step5: (1e) Tamanho de cada palavra Agora use map() e uma função lambda para retornar o número de caracteres em cada palavra. Utilize collect() para armazenar o resultado em forma de listas na variável destino. Step6: (1f) RDDs de pares e tuplas Para contar a frequência de cada palavra de maneira distribuída, primeiro devemos atribuir um valor para cada palavra do RDD. Isso irá gerar um base de dados (chave, valor). Desse modo podemos agrupar a base através da chave, calculando a soma dos valores atribuídos. No nosso caso, vamos atribuir o valor 1 para cada palavra. Um RDD contendo a estrutura de tupla chave-valor (k,v) é chamada de RDD de tuplas ou pair RDD. Vamos criar nosso RDD de pares usando a transformação map() com uma função lambda(). Step7: Parte 2 Step8: (2b) Calculando as contagens Após o groupByKey() nossa RDD contém elementos compostos da palavra, como chave, e um iterador contendo todos os valores correspondentes aquela chave. Utilizando a transformação mapValues() e a função sum(), contrua um novo RDD que consiste de tuplas (chave, soma). Step9: (2c) reduceByKey Um comando mais interessante para a contagem é o reduceByKey() que cria uma nova RDD de tuplas. Essa transformação aplica a transformação reduce() vista na aula anterior para os valores de cada chave. Dessa forma, a função de transformação pode ser aplicada em cada partição local para depois ser enviada para redistribuição de partições, reduzindo o total de dados sendo movidos e não mantendo listas grandes na memória. Step10: (2d) Agrupando os comandos A forma mais usual de realizar essa tarefa, partindo do nosso RDD palavrasRDD, é encadear os comandos map e reduceByKey em uma linha de comando. Step11: Parte 3 Step12: (3b) Calculando a Média de contagem de palavras Encontre a média de frequência das palavras utilizando o RDD contagem. Note que a função do comando reduce() é aplicada em cada tupla do RDD. Para realizar a soma das contagens, primeiro é necessário mapear o RDD para um RDD contendo apenas os valores das frequências (sem as chaves). Step14: Parte 4 Step16: (4b) Normalizando o texto Quando trabalhamos com dados reais, geralmente precisamos padronizar os atributos de tal forma que diferenças sutis por conta de erro de medição ou diferença de normatização, sejam desconsideradas. Para o próximo passo vamos padronizar o texto para Step17: (4c) Carregando arquivo texto Para a próxima parte vamos utilizar o livro Trabalhos completos de William Shakespeare do Projeto Gutenberg. Para converter um texto em uma RDD, utilizamos a função textFile() que recebe como entrada o nome do arquivo texto que queremos utilizar e o número de partições. O nome do arquivo texto pode se referir a um arquivo local ou uma URI de arquivo distribuído (ex. Step18: (4d) Extraindo as palavras Antes de poder usar nossa função Before we can use the contaPalavras(), temos ainda que trabalhar em cima da nossa RDD Step19: Conforme deve ter percebido, o uso da função map() gera uma lista para cada linha, criando um RDD contendo uma lista de listas. Para resolver esse problema, o Spark possui uma função análoga chamada flatMap() que aplica a transformação do map(), porém achatando o retorno em forma de lista para uma lista unidimensional. Step20: Nota Step21: (4e) Remover linhas vazias Para o próximo passo vamos filtrar as linhas vazias com o comando filter(). Uma linha vazia é uma string sem nenhum conteúdo. Step22: (4f) Contagem de palavras Agora que nossa RDD contém uma lista de palavras, podemos aplicar nossa função contaPalavras(). Aplique a função em nossa RDD e utilize a função takeOrdered para imprimir as 15 palavras mais frequentes. takeOrdered() pode receber um segundo parâmetro que instrui o Spark em como ordenar os elementos. Ex. Step24: Parte 5 Step28: (5b) Valores Categóricos Quando nossos objetos são representados por atributos categóricos, eles não possuem uma similaridade espacial. Para calcularmos a similaridade entre eles podemos primeiro transformar nosso vetor de atrbutos em um vetor binário indicando, para cada possível valor de cada atributo, se ele possui esse atributo ou não. Com o vetor binário podemos utilizar a distância de Hamming definida por	Python Code: from pyspark import SparkContext sc =SparkContext() ListaPalavras = ['gato', 'elefante', 'rato', 'rato', 'gato'] palavrasRDD = sc.parallelize(ListaPalavras, 4) print type(palavrasRDD) Explanation: Spark + Python = PySpark Esse notebook introduz os conceitos básicos do Spark através de sua interface com a linguagem Python. Como aplicação inicial faremos o clássico examplo de contador de palavras . Com esse exemplo é possível entender a lógica de programação funcional para as diversas tarefas de exploração de dados distribuídos. Para isso utilizaremos o livro texto Trabalhos completos de William Shakespeare obtidos do Projeto Gutenberg. Veremos que esse mesmo algoritmo pode ser empregado em textos de qualquer tamanho. Esse notebook contém: Parte 1: Criando uma base RDD e RDDs de tuplas Parte 2: Manipulando RDDs de tuplas Parte 3: Encontrando palavras únicas e calculando médias Parte 4: Aplicar contagem de palavras em um arquivo Parte 5: Similaridade entre Objetos Para os exercícios é aconselhável consultar a documentação da API do PySpark Part 1: Criando e Manipulando RDDs Nessa parte do notebook vamos criar uma base RDD a partir de uma lista com o comando parallelize. (1a) Criando uma base RDD Podemos criar uma base RDD de diversos tipos e fonte do Python com o comando sc.parallelize(fonte, particoes), sendo fonte uma variável contendo os dados (ex.: uma lista) e particoes o número de partições para trabalhar em paralelo. End of explanation # EXERCICIO def Plural(palavra): Adds an 's' to `palavra`. Args: palavra (str): A string. Returns: str: A string with 's' added to it. return "{0}{1}".format(palavra,"s")#<COMPLETAR> print Plural('gato') help(Plural) assert Plural('rato')=='ratos', 'resultado incorreto!' print 'OK' Explanation: (1b) Plural Vamos criar uma função que transforma uma palavra no plural adicionando uma letra 's' ao final da string. Em seguida vamos utilizar a função map() para aplicar a transformação em cada palavra do RDD. Em Python (e muitas outras linguagens) a concatenação de strings é custosa. Uma alternativa melhor é criar uma nova string utilizando str.format(). Nota: a string entre os conjuntos de três aspas representa a documentação da função. Essa documentação é exibida com o comando help(). Vamos utilizar a padronização de documentação sugerida para o Python, manteremos essa documentação em inglês. End of explanation # EXERCICIO pluralRDD = palavrasRDD.map(Plural)#<COMPLETAR> print pluralRDD.collect() assert pluralRDD.collect()==['gatos','elefantes','ratos','ratos','gatos'], 'valores incorretos!' print 'OK' Explanation: (1c) Aplicando a função ao RDD Transforme cada palavra do nosso RDD em plural usando map() Em seguida, utilizaremos o comando collect() que retorna a RDD como uma lista do Python. End of explanation # EXERCICIO pluralLambdaRDD = palavrasRDD.map(lambda x: "{0}{1}".format(x,"s"))#<COMPLETAR> print pluralLambdaRDD.collect() assert pluralLambdaRDD.collect()==['gatos','elefantes','ratos','ratos','gatos'], 'valores incorretos!' print 'OK' Explanation: Nota: utilize o comando collect() apenas quando tiver certeza de que a lista caberá na memória. Para gravar os resultados de volta em arquivo texto ou base de dados utilizaremos outro comando. (1d) Utilizando uma função lambda Repita a criação de um RDD de plurais, porém utilizando uma função lambda. End of explanation # EXERCICIO pluralTamanho = (pluralRDD.map(lambda x: len(x)) #<COMPLETAR> ).collect() print pluralTamanho assert pluralTamanho==[5,9,5,5,5], 'valores incorretos' print "OK" Explanation: (1e) Tamanho de cada palavra Agora use map() e uma função lambda para retornar o número de caracteres em cada palavra. Utilize collect() para armazenar o resultado em forma de listas na variável destino. End of explanation # EXERCICIO palavraPar = palavrasRDD.map(lambda x: (x,1))#<COMPLETAR> print palavraPar.collect() assert palavraPar.collect() == [('gato',1),('elefante',1),('rato',1),('rato',1),('gato',1)], 'valores incorretos!' print "OK" Explanation: (1f) RDDs de pares e tuplas Para contar a frequência de cada palavra de maneira distribuída, primeiro devemos atribuir um valor para cada palavra do RDD. Isso irá gerar um base de dados (chave, valor). Desse modo podemos agrupar a base através da chave, calculando a soma dos valores atribuídos. No nosso caso, vamos atribuir o valor 1 para cada palavra. Um RDD contendo a estrutura de tupla chave-valor (k,v) é chamada de RDD de tuplas ou pair RDD. Vamos criar nosso RDD de pares usando a transformação map() com uma função lambda(). End of explanation # EXERCICIO palavrasGrupo = palavraPar.groupByKey() for chave, valor in palavrasGrupo.collect(): print '{0}: {1}'.format(chave, list(valor)) assert sorted(palavrasGrupo.mapValues(lambda x: list(x)).collect()) == [('elefante', [1]), ('gato',[1, 1]), ('rato',[1, 1])], 'Valores incorretos!' print "OK" Explanation: Parte 2: Manipulando RDD de tuplas Vamos manipular nossa RDD para contar as palavras do texto. (2a) Função groupByKey() A função groupByKey() agrupa todos os valores de um RDD através da chave (primeiro elemento da tupla) agregando os valores em uma lista. Essa abordagem tem um ponto fraco pois: A operação requer que os dados distribuídos sejam movidos em massa para que permaneçam na partição correta. As listas podem se tornar muito grandes. Imagine contar todas as palavras do Wikipedia: termos comuns como "a", "e" formarão uma lista enorme de valores que pode não caber na memória do processo escravo. End of explanation # EXERCICIO contagemGroup = palavrasGrupo.mapValues(lambda x: sum (x))#<COMPLETAR> print contagemGroup.collect() assert list(sorted(contagemGroup.collect()))==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!' print "OK" Explanation: (2b) Calculando as contagens Após o groupByKey() nossa RDD contém elementos compostos da palavra, como chave, e um iterador contendo todos os valores correspondentes aquela chave. Utilizando a transformação mapValues() e a função sum(), contrua um novo RDD que consiste de tuplas (chave, soma). End of explanation # EXERCICIO from operator import add contagem = palavraPar.reduceByKey(add)#<COMPLETAR> print contagem.collect() assert sorted(contagem.collect())==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!' print "OK" Explanation: (2c) reduceByKey Um comando mais interessante para a contagem é o reduceByKey() que cria uma nova RDD de tuplas. Essa transformação aplica a transformação reduce() vista na aula anterior para os valores de cada chave. Dessa forma, a função de transformação pode ser aplicada em cada partição local para depois ser enviada para redistribuição de partições, reduzindo o total de dados sendo movidos e não mantendo listas grandes na memória. End of explanation # EXERCICIO contagemFinal = (palavrasRDD.map(lambda x:(x,1)).reduceByKey(add) #<COMPLETAR> #<COMPLETAR> ) contagemFinal = contagemFinal.collect() print contagemFinal assert sorted(contagemFinal)==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!' print "OK" Explanation: (2d) Agrupando os comandos A forma mais usual de realizar essa tarefa, partindo do nosso RDD palavrasRDD, é encadear os comandos map e reduceByKey em uma linha de comando. End of explanation # EXERCICIO palavrasUnicas = (palavrasRDD.map(lambda x:(x,1)).reduceByKey(lambda y,z:1)).collect()#<COMPLETAR> palavrasUnicas = len(palavrasUnicas) print palavrasUnicas assert palavrasUnicas==3, 'valor incorreto!' print "OK" Explanation: Parte 3: Encontrando as palavras únicas e calculando a média de contagem (3a) Palavras Únicas Calcule a quantidade de palavras únicas do RDD. Utilize comandos de RDD da API do PySpark e alguma das últimas RDDs geradas nos exercícios anteriores. End of explanation # EXERCICIO # add é equivalente a lambda x,y: x+y palavrasRDD2 = sc.parallelize(contagemFinal) #print palavrasRDD2.collect() total = (palavrasRDD2.map(lambda x:(x[1])).reduce(add)) media = total / float(palavrasUnicas) print total print round(media, 2) assert round(media, 2)==1.67, 'valores incorretos!' print "OK" Explanation: (3b) Calculando a Média de contagem de palavras Encontre a média de frequência das palavras utilizando o RDD contagem. Note que a função do comando reduce() é aplicada em cada tupla do RDD. Para realizar a soma das contagens, primeiro é necessário mapear o RDD para um RDD contendo apenas os valores das frequências (sem as chaves). End of explanation # EXERCICIO def contaPalavras(chavesRDD): Creates a pair RDD with word counts from an RDD of words. Args: chavesRDD (RDD of str): An RDD consisting of words. Returns: RDD of (str, int): An RDD consisting of (word, count) tuples. return (chavesRDD.map(lambda x: (x,1)).reduceByKey(add) #<COMPLETAR> #<COMPLETAR> ) print contaPalavras(palavrasRDD).collect() assert sorted(contaPalavras(palavrasRDD).collect())==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!' print "OK" Explanation: Parte 4: Aplicar nosso algoritmo em um arquivo (4a) Função contaPalavras Para podermos aplicar nosso algoritmo genéricamente em diversos RDDs, vamos primeiro criar uma função para aplicá-lo em qualquer fonte de dados. Essa função recebe de entrada um RDD contendo uma lista de chaves (palavras) e retorna um RDD de tuplas com as chaves e a contagem delas nessa RDD End of explanation # EXERCICIO import re def removerPontuacao(texto): Removes punctuation, changes to lower case, and strips leading and trailing spaces. Note: Only spaces, letters, and numbers should be retained. Other characters should should be eliminated (e.g. it's becomes its). Leading and trailing spaces should be removed after punctuation is removed. Args: texto (str): A string. Returns: str: The cleaned up string. return re.sub(r'[^A-Za-z0-9 ]', '', texto).strip().lower() print removerPontuacao('Ola, quem esta ai??!') print removerPontuacao(' Sem espaco e_sublinhado!') assert removerPontuacao(' O uso de virgulas, embora permitido, nao deve contar. ')=='o uso de virgulas embora permitido nao deve contar', 'string incorreta!' print "OK" Explanation: (4b) Normalizando o texto Quando trabalhamos com dados reais, geralmente precisamos padronizar os atributos de tal forma que diferenças sutis por conta de erro de medição ou diferença de normatização, sejam desconsideradas. Para o próximo passo vamos padronizar o texto para: Padronizar a capitalização das palavras (tudo maiúsculo ou tudo minúsculo). Remover pontuação. Remover espaços no início e no final da palavra. Crie uma função removerPontuacao que converte todo o texto para minúscula, remove qualquer pontuação e espaços em branco no início ou final da palavra. Para isso, utilize a biblioteca re para remover todo texto que não seja letra, número ou espaço, encadeando com as funções de string para remover espaços em branco e converter para minúscula (veja Strings). End of explanation # Apenas execute a célula import os.path import urllib2 url = 'http://www.gutenberg.org/cache/epub/100/pg100.txt' # url do livro arquivo = os.path.join('Data','Aula02','shakespeare.txt') # local de destino: 'Data/Aula02/shakespeare.txt' if os.path.isfile(arquivo): # verifica se já fizemos download do arquivo print 'Arquivo já existe!' else: try: response = urllib2.urlopen(url) arquivo = (response.read()).split() #ja gera uma lista de palavras except IOError: print 'Impossível fazer o download: {0}'.format(url) # lê o arquivo com textFile e aplica a função removerPontuacao shakesRDD = (sc.textFile(arquivo).map(removerPontuacao)) # zipWithIndex gera tuplas (conteudo, indice) onde indice é a posição do conteudo na lista sequencial # Ex.: sc.parallelize(['gato','cachorro','boi']).zipWithIndex() ==> [('gato',0), ('cachorro',1), ('boi',2)] # sep.join() junta as strings de uma lista através do separador sep. Ex.: ','.join(['a','b','c']) ==> 'a,b,c' print '\n'.join(shakesRDD .zipWithIndex() .map(lambda (linha, num): '{0}: {1}'.format(num,linha)) .take(15) ) Explanation: (4c) Carregando arquivo texto Para a próxima parte vamos utilizar o livro Trabalhos completos de William Shakespeare do Projeto Gutenberg. Para converter um texto em uma RDD, utilizamos a função textFile() que recebe como entrada o nome do arquivo texto que queremos utilizar e o número de partições. O nome do arquivo texto pode se referir a um arquivo local ou uma URI de arquivo distribuído (ex.: hdfs://). Vamos também aplicar a função removerPontuacao() para normalizar o texto e verificar as 15 primeiras linhas com o comando take(). End of explanation # EXERCICIO shakesPalavrasRDD = shakesRDD.map(lambda x: x.split())#<COMPLETAR> total = shakesPalavrasRDD.count() print shakesPalavrasRDD.take(5) print total Explanation: (4d) Extraindo as palavras Antes de poder usar nossa função Before we can use the contaPalavras(), temos ainda que trabalhar em cima da nossa RDD: Precisamos gerar listas de palavras ao invés de listas de sentenças. Eliminar linhas vazias. As strings em Python tem o método split() que faz a separação de uma string por separador. No nosso caso, queremos separar as strings por espaço. Utilize a função map() para gerar um novo RDD como uma lista de palavras. End of explanation # EXERCICIO shakesPalavrasRDD = shakesRDD.flatMap(lambda x: x.split()) total = shakesPalavrasRDD.count() print shakesPalavrasRDD.top(5) print total Explanation: Conforme deve ter percebido, o uso da função map() gera uma lista para cada linha, criando um RDD contendo uma lista de listas. Para resolver esse problema, o Spark possui uma função análoga chamada flatMap() que aplica a transformação do map(), porém achatando o retorno em forma de lista para uma lista unidimensional. End of explanation #assert total==927631 or total == 928908, "valor incorreto de palavras!" #print "OK" assert shakesPalavrasRDD.top(5)==[u'zwaggerd', u'zounds', u'zounds', u'zounds', u'zounds'],'lista incorreta de palavras' print "OK" Explanation: Nota: os asserts abaixo de contagem de palavra podem falhar por diferença de formato do arquivo .txt antigo e novo. Eu avaliarei somente os códigos nesse trecho. End of explanation # EXERCICIO shakesLimpoRDD = shakesPalavrasRDD.filter(lambda x: len(x)>0)#<COMPLETAR> total = shakesLimpoRDD.count() print total assert total==882996, 'valor incorreto!' print "OK" Explanation: (4e) Remover linhas vazias Para o próximo passo vamos filtrar as linhas vazias com o comando filter(). Uma linha vazia é uma string sem nenhum conteúdo. End of explanation # EXERCICIO #print contaPalavras(shakesLimpoRDD).collect() top15 = contaPalavras(shakesLimpoRDD).takeOrdered(15, lambda x: -x[1])#<COMPLETAR> print '\n'.join(map(lambda (w, c): '{0}: {1}'.format(w, c), top15)) assert top15 == [(u'the', 27361), (u'and', 26028), (u'i', 20681), (u'to', 19150), (u'of', 17463), (u'a', 14593), (u'you', 13615), (u'my', 12481), (u'in', 10956), (u'that', 10890), (u'is', 9134), (u'not', 8497), (u'with', 7771), (u'me', 7769), (u'it', 7678)],'valores incorretos!' print "OK" Explanation: (4f) Contagem de palavras Agora que nossa RDD contém uma lista de palavras, podemos aplicar nossa função contaPalavras(). Aplique a função em nossa RDD e utilize a função takeOrdered para imprimir as 15 palavras mais frequentes. takeOrdered() pode receber um segundo parâmetro que instrui o Spark em como ordenar os elementos. Ex.: takeOrdered(15, key=lambda x: -x): ordem decrescente dos valores de x End of explanation import numpy as np # Vamos criar uma função pNorm que recebe como parâmetro p e retorna uma função que calcula a pNorma def pNorm(p): Generates a function to calculate the p-Norm between two points. Args: p (int): The integer p. Returns: Dist: A function that calculates the p-Norm. def Dist(x,y): return np.power(np.power(np.abs(x-y),p).sum(),1/float(p)) return Dist # Vamos criar uma RDD com valores numéricos numPointsRDD = sc.parallelize(enumerate(np.random.random(size=(10,100)))) # EXERCICIO # Procure dentre os comandos do PySpark, um que consiga fazer o produto cartesiano da base com ela mesma cartPointsRDD = numPointsRDD.cartesian(numPointsRDD)#<COMPLETAR> # Aplique um mapa para transformar nossa RDD em uma RDD de tuplas ((id1,id2), (vetor1,vetor2)) # DICA: primeiro utilize o comando take(1) e imprima o resultado para verificar o formato atual da RDD cartPointsParesRDD = cartPointsRDD.map(lambda ((x1,x2),(y1,y2)):((x1,y1),(x2,y2)))#<COMPLETAR> #print cartPointsParesRDD #Aplique um mapa para calcular a Distância Euclidiana entre os pares Euclid = pNorm(2) distRDD = cartPointsParesRDD.map(lambda ((x1,y1),(x2,y2)): Euclid(x2,y2))#<COMPLETAR> #print(distRDD.collect()) # Encontre a distância máxima, mínima e média, aplicando um mapa que transforma (chave,valor) --> valor # e utilizando os comandos internos do pyspark para o cálculo da min, max, mean #statRDD = distRDD.<COMPLETAR> #minv, maxv, meanv = statRDD.<COMPLETAR>, statRDD.<COMPLETAR>, statRDD.<COMPLETAR> minv, maxv, meanv = distRDD.min(), distRDD.max(), distRDD.mean()#<COMPLETAR> print minv, maxv, meanv assert (minv.round(2), maxv.round(2), meanv.round(2))==(0.0, 4.70, 3.65), 'Valores incorretos' print "OK" Explanation: Parte 5: Similaridade entre Objetos Nessa parte do laboratório vamos aprender a calcular a distância entre atributos numéricos, categóricos e textuais. (5a) Vetores no espaço Euclidiano Quando nossos objetos são representados no espaço Euclidiano, medimos a similaridade entre eles através da p-Norma definida por: $$d(x,y,p) = (\sum_{i=1}^{n}{\|x_i - y_i\|^p})^{1/p}$$ As normas mais utilizadas são $p=1,2,\infty$ que se reduzem em distância absoluta, Euclidiana e máxima distância: $$d(x,y,1) = \sum_{i=1}^{n}{\|x_i - y_i\|}$$ $$d(x,y,2) = (\sum_{i=1}^{n}{\|x_i - y_i\|^2})^{1/2}$$ $$d(x,y,\infty) = \max(\|x_1 - y_1\|,\|x_2 - y_2\|, ..., \|x_n - y_n\|)$$ End of explanation # Vamos criar uma função para calcular a distância de Hamming def Hamming(x,y): Calculates the Hamming distance between two binary vectors. Args: x, y (np.array): Array of binary integers x and y. Returns: H (int): The Hamming distance between x and y. return (x!=y).sum() # Vamos criar uma função para calcular a distância de Jaccard def Jaccard(x,y): Calculates the Jaccard distance between two binary vectors. Args: x, y (np.array): Array of binary integers x and y. Returns: J (int): The Jaccard distance between x and y. return (x==y).sum()/float( np.maximum(x,y).sum() ) # Vamos criar uma RDD com valores categóricos catPointsRDD = sc.parallelize(enumerate([['alto', 'caro', 'azul'], ['medio', 'caro', 'verde'], ['alto', 'barato', 'azul'], ['medio', 'caro', 'vermelho'], ['baixo', 'barato', 'verde'], ])) # EXERCICIO # Crie um RDD de chaves únicas utilizando flatMap chavesRDD = catPointsRDD.flatMap(lambda x: (x[1])).distinct()#.zipWithIndex() chaves = dict((v,k) for k,v in enumerate(chavesRDD.collect())) nchaves = len(chaves) print chaves, nchaves assert chaves=={'alto': 0, 'medio': 1, 'baixo': 2, 'barato': 3, 'azul': 4, 'verde': 5, 'caro': 6, 'vermelho': 7}, 'valores incorretos!' print "OK" assert nchaves==8, 'número de chaves incorreta' print "OK" def CreateNP(atributos,chaves): Binarize the categorical vector using a dictionary of keys. Args: atributos (list): List of attributes of a given object. chaves (dict): dictionary with the relation attribute -> index Returns: array (np.array): Binary array of attributes. array = np.zeros(len(chaves)) for atr in atributos: array[ chaves[atr] ] = 1 return array # Converte o RDD para o formato binário, utilizando o dict chaves binRDD = catPointsRDD.map(lambda rec: (rec[0],CreateNP(rec[1], chaves))) binRDD.collect() # EXERCICIO # Procure dentre os comandos do PySpark, um que consiga fazer o produto cartesiano da base com ela mesma cartBinRDD = binRDD.cartesian(binRDD)#<COMPLETAR> # Aplique um mapa para transformar nossa RDD em uma RDD de tuplas ((id1,id2), (vetor1,vetor2)) # DICA: primeiro utilize o comando take(1) e imprima o resultado para verificar o formato atual da RDD cartBinParesRDD = cartBinRDD.map(lambda ((x1,x2),(y1,y2)):((x1,y1),(x2,y2)))#<COMPLETAR> distRDD = cartPointsParesRDD.map(lambda ((x1,y1),(x2,y2)): Euclid(x2,y2))#<COMPLETAR> # Aplique um mapa para calcular a Distância de Hamming e Jaccard entre os pares hamRDD = cartBinParesRDD.map(lambda ((x1,y1),(x2,y2)): Hamming(x2,y2))#<COMPLETAR> jacRDD = cartBinParesRDD.map(lambda ((x1,y1),(x2,y2)): Jaccard(x2,y2))#<COMPLETAR> # Encontre a distância máxima, mínima e média, aplicando um mapa que transforma (chave,valor) --> valor # e utilizando os comandos internos do pyspark para o cálculo da min, max, mean #statHRDD = hamRDD.<COMPLETAR> #statJRDD = jacRDD.<COMPLETAR> Hmin, Hmax, Hmean = hamRDD.min(), hamRDD.max(), hamRDD.mean() Jmin, Jmax, Jmean = jacRDD.min(), jacRDD.max(), jacRDD.mean() #Hmin, Hmax, Hmean = statHRDD.<COMPLETAR>, statHRDD.<COMPLETAR>, statHRDD.<COMPLETAR> #Jmin, Jmax, Jmean = statJRDD.<COMPLETAR>, statJRDD.<COMPLETAR>, statJRDD.<COMPLETAR> print "\t\tMin\tMax\tMean" print "Hamming:\t{:.2f}\t{:.2f}\t{:.2f}".format(Hmin, Hmax, Hmean ) print "Jaccard:\t{:.2f}\t{:.2f}\t{:.2f}".format( Jmin, Jmax, Jmean ) assert (Hmin.round(2), Hmax.round(2), Hmean.round(2)) == (0.00,6.00,3.52), 'valores incorretos' print "OK" assert (Jmin.round(2), Jmax.round(2), Jmean.round(2)) == (0.33,2.67,1.14), 'valores incorretos' print "OK" Explanation: (5b) Valores Categóricos Quando nossos objetos são representados por atributos categóricos, eles não possuem uma similaridade espacial. Para calcularmos a similaridade entre eles podemos primeiro transformar nosso vetor de atrbutos em um vetor binário indicando, para cada possível valor de cada atributo, se ele possui esse atributo ou não. Com o vetor binário podemos utilizar a distância de Hamming definida por: $$ H(x,y) = \sum_{i=1}^{n}{x_i != y_i} $$ Também é possível definir a distância de Jaccard como: $$ J(x,y) = \frac{\sum_{i=1}^{n}{x_i == y_i} }{\sum_{i=1}^{n}{\max(x_i, y_i}) } $$ End of explanation
12,406	Given the following text description, write Python code to implement the functionality described below step by step Description: Source localization with MNE/dSPM/sLORETA/eLORETA The aim of this tutorial is to teach you how to compute and apply a linear inverse method such as MNE/dSPM/sLORETA/eLORETA on evoked/raw/epochs data. Step1: Process MEG data Step2: Compute regularized noise covariance For more details see tut_compute_covariance. Step3: Compute the evoked response Let's just use MEG channels for simplicity. Step4: Inverse modeling Step5: Compute inverse solution Step6: Visualization View activation time-series Step7: Examine the original data and the residual after fitting Step8: Here we use peak getter to move visualization to the time point of the peak and draw a marker at the maximum peak vertex. Step9: Morph data to average brain Step10: Dipole orientations The pick_ori parameter of the Step11: Note that there is a relationship between the orientation of the dipoles and the surface of the cortex. For this reason, we do not use an inflated cortical surface for visualization, but the original surface used to define the source space. For more information about dipole orientations, see sphx_glr_auto_tutorials_plot_dipole_orientations.py. Now let's look at each solver	Python Code: # sphinx_gallery_thumbnail_number = 10 import numpy as np import matplotlib.pyplot as plt import mne from mne.datasets import sample from mne.minimum_norm import make_inverse_operator, apply_inverse Explanation: Source localization with MNE/dSPM/sLORETA/eLORETA The aim of this tutorial is to teach you how to compute and apply a linear inverse method such as MNE/dSPM/sLORETA/eLORETA on evoked/raw/epochs data. End of explanation data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' raw = mne.io.read_raw_fif(raw_fname) # already has an average reference events = mne.find_events(raw, stim_channel='STI 014') event_id = dict(aud_l=1) # event trigger and conditions tmin = -0.2 # start of each epoch (200ms before the trigger) tmax = 0.5 # end of each epoch (500ms after the trigger) raw.info['bads'] = ['MEG 2443', 'EEG 053'] picks = mne.pick_types(raw.info, meg=True, eeg=False, eog=True, exclude='bads') baseline = (None, 0) # means from the first instant to t = 0 reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=baseline, reject=reject) Explanation: Process MEG data End of explanation noise_cov = mne.compute_covariance( epochs, tmax=0., method=['shrunk', 'empirical'], rank=None, verbose=True) fig_cov, fig_spectra = mne.viz.plot_cov(noise_cov, raw.info) Explanation: Compute regularized noise covariance For more details see tut_compute_covariance. End of explanation evoked = epochs.average().pick_types(meg=True) evoked.plot(time_unit='s') evoked.plot_topomap(times=np.linspace(0.05, 0.15, 5), ch_type='mag', time_unit='s') # Show whitening evoked.plot_white(noise_cov, time_unit='s') del epochs # to save memory Explanation: Compute the evoked response Let's just use MEG channels for simplicity. End of explanation # Read the forward solution and compute the inverse operator fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-oct-6-fwd.fif' fwd = mne.read_forward_solution(fname_fwd) # make an MEG inverse operator info = evoked.info inverse_operator = make_inverse_operator(info, fwd, noise_cov, loose=0.2, depth=0.8) del fwd # You can write it to disk with:: # # >>> from mne.minimum_norm import write_inverse_operator # >>> write_inverse_operator('sample_audvis-meg-oct-6-inv.fif', # inverse_operator) Explanation: Inverse modeling: MNE/dSPM on evoked and raw data End of explanation method = "dSPM" snr = 3. lambda2 = 1. / snr ** 2 stc, residual = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori=None, return_residual=True, verbose=True) Explanation: Compute inverse solution End of explanation plt.figure() plt.plot(1e3 * stc.times, stc.data[::100, :].T) plt.xlabel('time (ms)') plt.ylabel('%s value' % method) plt.show() Explanation: Visualization View activation time-series End of explanation fig, axes = plt.subplots(2, 1) evoked.plot(axes=axes) for ax in axes: ax.texts = [] for line in ax.lines: line.set_color('#98df81') residual.plot(axes=axes) Explanation: Examine the original data and the residual after fitting: End of explanation vertno_max, time_max = stc.get_peak(hemi='rh') subjects_dir = data_path + '/subjects' surfer_kwargs = dict( hemi='rh', subjects_dir=subjects_dir, clim=dict(kind='value', lims=[8, 12, 15]), views='lateral', initial_time=time_max, time_unit='s', size=(800, 800), smoothing_steps=5) brain = stc.plot(surfer_kwargs) brain.add_foci(vertno_max, coords_as_verts=True, hemi='rh', color='blue', scale_factor=0.6, alpha=0.5) brain.add_text(0.1, 0.9, 'dSPM (plus location of maximal activation)', 'title', font_size=14) Explanation: Here we use peak getter to move visualization to the time point of the peak and draw a marker at the maximum peak vertex. End of explanation # setup source morph morph = mne.compute_source_morph( src=inverse_operator['src'], subject_from=stc.subject, subject_to='fsaverage', spacing=5, # to ico-5 subjects_dir=subjects_dir) # morph data stc_fsaverage = morph.apply(stc) brain = stc_fsaverage.plot(surfer_kwargs) brain.add_text(0.1, 0.9, 'Morphed to fsaverage', 'title', font_size=20) del stc_fsaverage Explanation: Morph data to average brain End of explanation stc_vec = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori='vector') brain = stc_vec.plot(surfer_kwargs) brain.add_text(0.1, 0.9, 'Vector solution', 'title', font_size=20) del stc_vec Explanation: Dipole orientations The pick_ori parameter of the :func:mne.minimum_norm.apply_inverse function controls the orientation of the dipoles. One useful setting is pick_ori='vector', which will return an estimate that does not only contain the source power at each dipole, but also the orientation of the dipoles. End of explanation for mi, (method, lims) in enumerate((('dSPM', [8, 12, 15]), ('sLORETA', [3, 5, 7]), ('eLORETA', [0.75, 1.25, 1.75]),)): surfer_kwargs['clim']['lims'] = lims stc = apply_inverse(evoked, inverse_operator, lambda2, method=method, pick_ori=None) brain = stc.plot(figure=mi, surfer_kwargs) brain.add_text(0.1, 0.9, method, 'title', font_size=20) del stc Explanation: Note that there is a relationship between the orientation of the dipoles and the surface of the cortex. For this reason, we do not use an inflated cortical surface for visualization, but the original surface used to define the source space. For more information about dipole orientations, see sphx_glr_auto_tutorials_plot_dipole_orientations.py. Now let's look at each solver: End of explanation
12,407	Given the following text description, write Python code to implement the functionality described below step by step Description: CrowdTruth for Multiple Choice Tasks Step1: Declaring a pre-processing configuration The pre-processing configuration defines how to interpret the raw crowdsourcing input. To do this, we need to define a configuration class. First, we import the default CrowdTruth configuration class Step2: Our test class inherits the default configuration DefaultConfig, while also declaring some additional attributes that are specific to the Relation Extraction task Step3: Pre-processing the input data After declaring the configuration of our input file, we are ready to pre-process the crowd data Step4: Computing the CrowdTruth metrics The pre-processed data can then be used to calculate the CrowdTruth metrics Step5: results is a dict object that contains the quality metrics for sentences, relations and crowd workers. The sentence metrics are stored in results["units"] Step6: The uqs column in results["units"] contains the sentence quality scores, capturing the overall workers agreement over each sentence. Here we plot its histogram Step7: The unit_annotation_score column in results["units"] contains the sentence-relation scores, capturing the likelihood that a relation is expressed in a sentence. For each sentence, we store a dictionary mapping each relation to its sentence-relation score. Step8: The worker metrics are stored in results["workers"] Step9: The wqs columns in results["workers"] contains the worker quality scores, capturing the overall agreement between one worker and all the other workers. Step10: The relation metrics are stored in results["annotations"]. The aqs column contains the relation quality scores, capturing the overall worker agreement over one relation.	Python Code: import pandas as pd test_data = pd.read_csv("../data/relex-multiple-choice.csv") test_data.head() Explanation: CrowdTruth for Multiple Choice Tasks: Relation Extraction In this tutorial, we will apply CrowdTruth metrics to a multiple choice crowdsourcing task for Relation Extraction from sentences. The workers were asked to read a sentence with 2 highlighted terms, then pick from a multiple choice list what are the relations expressed between the 2 terms in the sentence. The task was executed on FigureEight. For more crowdsourcing annotation task examples, click here. To replicate this experiment, the code used to design and implement this crowdsourcing annotation template is available here: template, css, javascript. This is a screenshot of the task as it appeared to workers: A sample dataset for this task is available in this file, containing raw output from the crowd on FigureEight. Download the file and place it in a folder named data that has the same root as this notebook. Now you can check your data: End of explanation import crowdtruth from crowdtruth.configuration import DefaultConfig Explanation: Declaring a pre-processing configuration The pre-processing configuration defines how to interpret the raw crowdsourcing input. To do this, we need to define a configuration class. First, we import the default CrowdTruth configuration class: End of explanation class TestConfig(DefaultConfig): inputColumns = ["sent_id", "term1", "b1", "e1", "term2", "b2", "e2", "sentence"] outputColumns = ["relations"] annotation_separator = "\n" # processing of a closed task open_ended_task = False annotation_vector = [ "title", "founded_org", "place_of_birth", "children", "cause_of_death", "top_member_employee_of_org", "employee_or_member_of", "spouse", "alternate_names", "subsidiaries", "place_of_death", "schools_attended", "place_of_headquarters", "charges", "origin", "places_of_residence", "none"] def processJudgments(self, judgments): # pre-process output to match the values in annotation_vector for col in self.outputColumns: # transform to lowercase judgments[col] = judgments[col].apply(lambda x: str(x).lower()) return judgments Explanation: Our test class inherits the default configuration DefaultConfig, while also declaring some additional attributes that are specific to the Relation Extraction task: inputColumns: list of input columns from the .csv file with the input data outputColumns: list of output columns from the .csv file with the answers from the workers annotation_separator: string that separates between the crowd annotations in outputColumns open_ended_task: boolean variable defining whether the task is open-ended (i.e. the possible crowd annotations are not known beforehand, like in the case of free text input); in the task that we are processing, workers pick the answers from a pre-defined list, therefore the task is not open ended, and this variable is set to False annotation_vector: list of possible crowd answers, mandatory to declare when open_ended_task is False; for our task, this is the list of relations processJudgments: method that defines processing of the raw crowd data; for this task, we process the crowd answers to correspond to the values in annotation_vector The complete configuration class is declared below: End of explanation data, config = crowdtruth.load( file = "../data/relex-multiple-choice.csv", config = TestConfig() ) data['judgments'].head() Explanation: Pre-processing the input data After declaring the configuration of our input file, we are ready to pre-process the crowd data: End of explanation results = crowdtruth.run(data, config) Explanation: Computing the CrowdTruth metrics The pre-processed data can then be used to calculate the CrowdTruth metrics: End of explanation results["units"].head() Explanation: results is a dict object that contains the quality metrics for sentences, relations and crowd workers. The sentence metrics are stored in results["units"]: End of explanation import matplotlib.pyplot as plt %matplotlib inline plt.hist(results["units"]["uqs"]) plt.xlabel("Sentence Quality Score") plt.ylabel("Sentences") Explanation: The uqs column in results["units"] contains the sentence quality scores, capturing the overall workers agreement over each sentence. Here we plot its histogram: End of explanation results["units"]["unit_annotation_score"].head() Explanation: The unit_annotation_score column in results["units"] contains the sentence-relation scores, capturing the likelihood that a relation is expressed in a sentence. For each sentence, we store a dictionary mapping each relation to its sentence-relation score. End of explanation results["workers"].head() Explanation: The worker metrics are stored in results["workers"]: End of explanation plt.hist(results["workers"]["wqs"]) plt.xlabel("Worker Quality Score") plt.ylabel("Workers") Explanation: The wqs columns in results["workers"] contains the worker quality scores, capturing the overall agreement between one worker and all the other workers. End of explanation results["annotations"] Explanation: The relation metrics are stored in results["annotations"]. The aqs column contains the relation quality scores, capturing the overall worker agreement over one relation. End of explanation
12,408	Given the following text description, write Python code to implement the functionality described below step by step Description: GitHub Analiza iz V tem projektu bomo analizirali najpopularnejše odprte repozitorije na priljubljeni strani GitHub. Podatki so bili zajeti iz https Step1: Naložimo zajete podatke in si oglejmo primer. Step2: Pandas nam omogoči hiter pregled osnovnih številčnih izračunov. Step3: Sedaj si poglejmo, katerega leta so bili ti repozitoriji ustvarjeni. Step4: Vidimo, da je največ projektov nastalo v letih 2013 in 2014, prej GitHub še ni bil tako popularen, novejši projekti pa še niso imeli časa da zaslovijo. Pogosto bomo uporabljali repozitorije grupirane po jezikih, da pa bo analiza lažja vzemimo le tiste jezike z več kot 10 repozitoriji. Step5: Zdaj pa si oglejmo, kateri programski jeziki se najpogosteje pojavijo. Prikazali bomo le tiste z več kot 10 repozitoriji, saj drugače ne dobimo uporabnega grafa. Vidimo, da prevladuje JavaScript, sledijo pa mu Java, Objective-C in Python. Step6: Narišimo še graf, ki prikazuje odvisnost števila forkov od števila zvezdic. Poskusimo lahko to odvisnost predstaviti kot linearno funkcijo, a hitro vidimo, da prihaja do velikih odstopanj. Vseeno pa iz naraščujoče funkcije lahko sklepamo, da imajo repozitoriji z več zvezdicamo tudi več forkov. Step7: Oglejmo si še kako je povezano število commitov z programskim jezikom uporabljenim. Vidimo, da so se najbolj spreminjali repozitoriji v VimL, Shell in Objective-C, najmanj pa C++, Ruby in Coffescript. Step8: Izpis licenc uporabljenih v teh repozitorijih, razvrščene po vrstnem redu. None pomeni, da licenca ni objavljena, Other pa da uporabljajo lastno licenco. Step9: Za konec ugotovimo še, koliko izmed teh repozitorijev je sveže posodobljenih (imajo spremebe v zadnje mesecu). True pomeni, da ima spremebe, False da ne.	Python Code: import pandas as pd import numpy as np import matplotlib.pyplot as plt %matplotlib inline pd.options.display.max_rows = 20 Explanation: GitHub Analiza iz V tem projektu bomo analizirali najpopularnejše odprte repozitorije na priljubljeni strani GitHub. Podatki so bili zajeti iz https://api.github.com, kar pa v tem REST API-ju ni bilo dosegljivo pa iz https://github.com. Zajeti podatki lastnik ime programski jezik število zvezdic število commitov število vej število forkov število izdaj število gledalcev število contributorjev licenca datum nastanka datum zadnjega commita Analizirali bomo, kateri so najpriljubljenejši programski jeziki, kako "veliki" so ti repozitoriji,... in pa kako so ti podatki povezani med seboj. End of explanation repos = pd.read_csv('../data/repositories.csv', parse_dates=[11,12,13]) repos Explanation: Naložimo zajete podatke in si oglejmo primer. End of explanation repos.describe() Explanation: Pandas nam omogoči hiter pregled osnovnih številčnih izračunov. End of explanation repos.groupby(repos.created_at.dt.year).size().plot(kind='bar') Explanation: Sedaj si poglejmo, katerega leta so bili ti repozitoriji ustvarjeni. End of explanation top_languages = repos.groupby("language").filter(lambda x: len(x) > 10).groupby("language") Explanation: Vidimo, da je največ projektov nastalo v letih 2013 in 2014, prej GitHub še ni bil tako popularen, novejši projekti pa še niso imeli časa da zaslovijo. Pogosto bomo uporabljali repozitorije grupirane po jezikih, da pa bo analiza lažja vzemimo le tiste jezike z več kot 10 repozitoriji. End of explanation by_lang_pie = top_languages.size().sort_values().plot(kind='pie',figsize=(7, 7), fontsize=13) by_lang_pie.set_ylabel("") #Removes the none Explanation: Zdaj pa si oglejmo, kateri programski jeziki se najpogosteje pojavijo. Prikazali bomo le tiste z več kot 10 repozitoriji, saj drugače ne dobimo uporabnega grafa. Vidimo, da prevladuje JavaScript, sledijo pa mu Java, Objective-C in Python. End of explanation df = repos.copy() z = np.polyfit(x=df.loc[:, 'stargazers_count'], y=df['forks_count'], deg=1) p = np.poly1d(z) df['trendline'] = p(df.loc[:, 'stargazers_count']) ax = df.plot.scatter(x='stargazers_count', y='forks_count', color='green') df.set_index('stargazers_count', inplace=True) df.trendline.sort_index(ascending=False).plot(ax=ax, color='red') plt.gca().invert_xaxis() ax.set_ylim(0, 6000) ax.set_xlim(0, 30000) Explanation: Narišimo še graf, ki prikazuje odvisnost števila forkov od števila zvezdic. Poskusimo lahko to odvisnost predstaviti kot linearno funkcijo, a hitro vidimo, da prihaja do velikih odstopanj. Vseeno pa iz naraščujoče funkcije lahko sklepamo, da imajo repozitoriji z več zvezdicamo tudi več forkov. End of explanation top_languages[["commit_count"]].mean().sort_values("commit_count").plot(kind='bar') Explanation: Oglejmo si še kako je povezano število commitov z programskim jezikom uporabljenim. Vidimo, da so se najbolj spreminjali repozitoriji v VimL, Shell in Objective-C, najmanj pa C++, Ruby in Coffescript. End of explanation repos.groupby("license").size().sort_values(ascending=False) Explanation: Izpis licenc uporabljenih v teh repozitorijih, razvrščene po vrstnem redu. None pomeni, da licenca ni objavljena, Other pa da uporabljajo lastno licenco. End of explanation pushed_pie = repos.groupby(repos.pushed_at >= "2016-10-03").size().plot(kind='pie',figsize=(7, 7), autopct='%.2f%%') pushed_pie.set_ylabel("") #Removes the none Explanation: Za konec ugotovimo še, koliko izmed teh repozitorijev je sveže posodobljenih (imajo spremebe v zadnje mesecu). True pomeni, da ima spremebe, False da ne. End of explanation
12,409	Given the following text description, write Python code to implement the functionality described below step by step Description: How many movies are listed in the titles dataframe? Step1: What are the earliest two films listed in the titles dataframe? Step2: How many movies have the title "Hamlet"? Step3: How many movies are titled "North by Northwest"? Step4: When was the first movie titled "Hamlet" made? Step5: List all of the "Treasure Island" movies from earliest to most recent. Step6: How many movies were made in the year 1950? Step7: How many movies were made in the year 1960? Step8: How many movies were made from 1950 through 1959? Step9: In what years has a movie titled "Batman" been released? How many roles were there in the movie "Inception"? How many roles in the movie "Inception" are NOT ranked by an "n" value? But how many roles in the movie "Inception" did receive an "n" value? Display the cast of "North by Northwest" in their correct "n"-value order, ignoring roles that did not earn a numeric "n" value. Display the entire cast, in "n"-order, of the 1972 film "Sleuth". Now display the entire cast, in "n"-order, of the 2007 version of "Sleuth". How many roles were credited in the silent 1921 version of Hamlet? How many roles were credited in Branagh’s 1996 Hamlet? How many "Hamlet" roles have been listed in all film credits through history? How many people have played an "Ophelia"? How many people have played a role called "The Dude"? How many people have played a role called "The Stranger"? How many roles has Sidney Poitier played throughout his career? How many roles has Judi Dench played? List the supporting roles (having n=2) played by Cary Grant in the 1940s, in order by year. List the leading roles that Cary Grant played in the 1940s in order by year. How many roles were available for actors in the 1950s? How many roles were avilable for actresses in the 1950s? How many leading roles (n=1) were available from the beginning of film history through 1980? How many non-leading roles were available through from the beginning of film history through 1980? How many roles through 1980 were minor enough that they did not warrant a numeric "n" rank?	Python Code: titles.tail() len(titles) Explanation: How many movies are listed in the titles dataframe? End of explanation titles.sort(columns='year', ascending=True).head()[:2] Explanation: What are the earliest two films listed in the titles dataframe? End of explanation titles[titles['title'].str.contains('Hamlet')].sort('year') Explanation: How many movies have the title "Hamlet"? End of explanation len(titles[titles.title == 'North by Northwest']) Explanation: How many movies are titled "North by Northwest"? End of explanation titles[titles['title'] 'Hamlet'].sort('year')[:1] Explanation: When was the first movie titled "Hamlet" made? End of explanation titles[titles.title == 'Treasure Island'].sort('year') Explanation: List all of the "Treasure Island" movies from earliest to most recent. End of explanation len(titles[titles.year == 1950]) Explanation: How many movies were made in the year 1950? End of explanation movies_of_1960 = titles[titles.year == 1960] len(movies_of_1960) Explanation: How many movies were made in the year 1960? End of explanation moviesOf1950And1959 = titles[(titles.year >= 1950) & (titles.year <= 1950)] len(moviesOf1950And1959) Explanation: How many movies were made from 1950 through 1959? End of explanation titles.year.value_counts().sort_index().plot() Explanation: In what years has a movie titled "Batman" been released? How many roles were there in the movie "Inception"? How many roles in the movie "Inception" are NOT ranked by an "n" value? But how many roles in the movie "Inception" did receive an "n" value? Display the cast of "North by Northwest" in their correct "n"-value order, ignoring roles that did not earn a numeric "n" value. Display the entire cast, in "n"-order, of the 1972 film "Sleuth". Now display the entire cast, in "n"-order, of the 2007 version of "Sleuth". How many roles were credited in the silent 1921 version of Hamlet? How many roles were credited in Branagh’s 1996 Hamlet? How many "Hamlet" roles have been listed in all film credits through history? How many people have played an "Ophelia"? How many people have played a role called "The Dude"? How many people have played a role called "The Stranger"? How many roles has Sidney Poitier played throughout his career? How many roles has Judi Dench played? List the supporting roles (having n=2) played by Cary Grant in the 1940s, in order by year. List the leading roles that Cary Grant played in the 1940s in order by year. How many roles were available for actors in the 1950s? How many roles were avilable for actresses in the 1950s? How many leading roles (n=1) were available from the beginning of film history through 1980? How many non-leading roles were available through from the beginning of film history through 1980? How many roles through 1980 were minor enough that they did not warrant a numeric "n" rank? End of explanation
12,410	Given the following text description, write Python code to implement the functionality described below step by step Description: Conventional "dB-differencing" analysis Step1: Set params and load clean MVBS data Step2: dB-differencing operation Here I used the criteria from Sato et al. 2015 for dB-differencing. The rationale is that this is the latest publication in nearby region and the classification threshold was selected based on trawl-verified animal groups. The classification rules are	Python Code: import os, sys, glob, re import datetime as dt import numpy as np from matplotlib.dates import date2num,num2date import h5py sys.path.insert(0,'..') sys.path.insert(0,'../mi_instrument/') import db_diff import decomp_plot import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1 import make_axes_locatable %matplotlib inline Explanation: Conventional "dB-differencing" analysis End of explanation # Set param ping_time_param_names = ["hour_all","min_all","sec_all"] ping_time_param_vals = (range(24),range(20),range(0,60,5)) ping_time_param = dict(zip(ping_time_param_names,ping_time_param_vals)) ping_per_day = len(ping_time_param['hour_all'])len(ping_time_param['min_all'])len(ping_time_param['sec_all']) ping_bin_range = 40 depth_bin_range = 10 tvg_correction_factor = 2 ping_per_day_mvbs = ping_per_day/ping_bin_range MVBS_path = '/media/wu-jung/wjlee_apl_2/ooi_zplsc_new/' MVBS_fname = '20150817-20151017_MVBS.h5' f = h5py.File(os.path.join(MVBS_path,MVBS_fname),"r") MVBS = np.array(f['MVBS']) depth_bin_size = np.array(f['depth_bin_size']) ping_time = np.array(f['ping_time']) f.close() # db_diff.plot_echogram(MVBS,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),'magma') db_diff.plot_echogram(MVBS,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),db_diff.e_cmap) Explanation: Set params and load clean MVBS data End of explanation Sv_1 = MVBS[2,:,:] Sv_2 = MVBS[0,:,:] yes_1 = ~np.isnan(Sv_1) yes_2 = ~np.isnan(Sv_2) Sv_diff_12 = Sv_1 - Sv_2 Sv_diff_12[yes_1 & ~yes_2] = np.inf Sv_diff_12[~yes_1 & yes_2] = -np.inf idx_fish = (np.isneginf(Sv_diff_12) \| (Sv_diff_12<=2)) & (Sv_diff_12>-16) idx_zoop = np.isposinf(Sv_diff_12) \| ((Sv_diff_12>2) & (Sv_diff_12<30)) idx_other = (Sv_diff_12<=-16) \| (Sv_diff_12>=30) MVBS_fish = np.ma.empty(MVBS.shape) for ff in range(MVBS.shape[0]): MVBS_fish[ff,:,:] = np.ma.masked_where(~idx_fish,MVBS[ff,:,:]) MVBS_zoop = np.ma.empty(MVBS.shape) for ff in range(MVBS.shape[0]): MVBS_zoop[ff,:,:] = np.ma.masked_where(~idx_zoop,MVBS[ff,:,:]) MVBS_others = np.ma.empty(MVBS.shape) for ff in range(MVBS.shape[0]): MVBS_others[ff,:,:] = np.ma.masked_where(~idx_other,MVBS[ff,:,:]) # db_diff.plot_echogram(MVBS_fish,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),'magma') db_diff.plot_echogram(MVBS_fish,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),db_diff.e_cmap) plt.gcf() plt.savefig(os.path.join(MVBS_path,'echogram_day01-62_ek60_fish.png'),dpi=150) # db_diff.plot_echogram(MVBS_zoop,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),'magma') db_diff.plot_echogram(MVBS_zoop,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),db_diff.e_cmap) plt.gcf() plt.savefig(os.path.join(MVBS_path,'echogram_day01-62_ek60_zoop.png'),dpi=150) # db_diff.plot_echogram(MVBS_others,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),'magma') db_diff.plot_echogram(MVBS_others,1,62,5,ping_per_day_mvbs,depth_bin_size,ping_time,(36,8),db_diff.e_cmap) plt.gcf() plt.savefig(os.path.join(MVBS_path,'echogram_day01-62_ek60_others.png'),dpi=150) Explanation: dB-differencing operation Here I used the criteria from Sato et al. 2015 for dB-differencing. The rationale is that this is the latest publication in nearby region and the classification threshold was selected based on trawl-verified animal groups. The classification rules are: - Fish: -16dB < Sv_200-Sv_38 <= 2dB - Zooplankton: 2dB < Sv_200-Sv_38 < 30dB - Others: 30dB < Sv_200-Sv_38 or Sv_200-Sv_38 <= -16dB End of explanation
12,411	Given the following text description, write Python code to implement the functionality described below step by step Description: DATA 643 - Final Project Sreejaya Nair and Suman K Polavarapu Description Step1: Prepare the pySpark Environment Step2: Initialize Spark Context Step3: Load and Analyse Data Step4: Ratings Histogram Step5: Most popular movies Step6: Similar Movies Find similar movies for a given movie using cosine similarity Step7: Lets find similar movies for Toy Story (Movie ID Step8: Recommender using MLLib Training the recommendation model Step9: Recommendations	Python Code: import os import sys import urllib2 import collections import matplotlib.pyplot as plt import math from time import time, sleep %pylab inline Explanation: DATA 643 - Final Project Sreejaya Nair and Suman K Polavarapu Description: Explore the Apache Spark Cluster Computing Framework by analysing the movielens dataset. Provide recommendations using MLLib End of explanation spark_home = os.environ.get('SPARK_HOME', None) if not spark_home: raise ValueError("Please set SPARK_HOME environment variable!") # Add the py4j to the path. sys.path.insert(0, os.path.join(spark_home, 'python')) sys.path.insert(0, os.path.join(spark_home, 'C:/spark/python/lib/py4j-0.9-src.zip')) Explanation: Prepare the pySpark Environment End of explanation from pyspark.mllib.recommendation import ALS, Rating from pyspark import SparkConf, SparkContext conf = SparkConf().setMaster("local[]").setAppName("MovieRecommendationsALS").set("spark.executor.memory", "2g") sc = SparkContext(conf = conf) Explanation: Initialize Spark Context End of explanation def loadMovieNames(): movieNames = {} for line in urllib2.urlopen("https://raw.githubusercontent.com/psumank/DATA643/master/WK5/ml-100k/u.item"): fields = line.split('\|') movieNames[int(fields[0])] = fields[1].decode('ascii', 'ignore') return movieNames print "\nLoading movie names..." nameDict = loadMovieNames() print "\nLoading ratings data..." data = sc.textFile("file:///C:/Users/p_sum/.ipynb_checkpoints/ml-100k/u.data") ratings = data.map(lambda x: x.split()[2]) #action -- just to trigger the driver [ lazy evaluation ] rating_results = ratings.countByValue() sortedResults = collections.OrderedDict(sorted(rating_results.items())) for key, value in sortedResults.iteritems(): print "%s %i" % (key, value) Explanation: Load and Analyse Data End of explanation ratPlot = plt.bar(range(len(sortedResults)), sortedResults.values(), align='center') plt.xticks(range(len(sortedResults)), list(sortedResults.keys())) ratPlot[3].set_color('g') print "Ratings Histogram" Explanation: Ratings Histogram End of explanation movies = data.map(lambda x: (int(x.split()[1]), 1)) movieCounts = movies.reduceByKey(lambda x, y: x + y) flipped = movieCounts.map( lambda (x, y) : (y, x)) sortedMovies = flipped.sortByKey(False) sortedMoviesWithNames = sortedMovies.map(lambda (count, movie) : (nameDict[movie], count)) results = sortedMoviesWithNames.collect() subset = results[0:10] popular_movieNm = [str(i[0]) for i in subset] popularity_strength = [int(i[1]) for i in subset] popMovplot = plt.barh(range(len(subset)), popularity_strength, align='center') plt.yticks(range(len(subset)), popular_movieNm) popMovplot[0].set_color('g') print "Most Popular Movies from the Dataset" Explanation: Most popular movies End of explanation ratingsRDD = data.map(lambda l: l.split()).map(lambda l: (int(l[0]), (int(l[1]), float(l[2])))) ratingsRDD.takeOrdered(10, key = lambda x: x[0]) ratingsRDD.take(4) # Movies rated by same user. ==> [ user ID ==> ( (movieID, rating), (movieID, rating)) ] userJoinedRatings = ratingsRDD.join(ratingsRDD) userJoinedRatings.takeOrdered(10, key = lambda x: x[0]) # Remove dups def filterDups( (userID, ratings) ): (movie1, rating1) = ratings[0] (movie2, rating2) = ratings[1] return movie1 < movie2 uniqueUserJoinedRatings = userJoinedRatings.filter(filterDups) uniqueUserJoinedRatings.takeOrdered(10, key = lambda x: x[0]) # Now key by (movie1, movie2) pairs ==> (movie1, movie2) => (rating1, rating2) def makeMovieRatingPairs((user, ratings)): (movie1, rating1) = ratings[0] (movie2, rating2) = ratings[1] return ((movie1, movie2), (rating1, rating2)) moviePairs = uniqueUserJoinedRatings.map(makeMovieRatingPairs) moviePairs.takeOrdered(10, key = lambda x: x[0]) #collect all ratings for each movie pair and compute similarity. (movie1, movie2) = > (rating1, rating2), (rating1, rating2) ... moviePairRatings = moviePairs.groupByKey() moviePairRatings.takeOrdered(10, key = lambda x: x[0]) #Compute Similarity def cosineSimilarity(ratingPairs): numPairs = 0 sum_xx = sum_yy = sum_xy = 0 for ratingX, ratingY in ratingPairs: sum_xx += ratingX ratingX sum_yy += ratingY * ratingY sum_xy += ratingX * ratingY numPairs += 1 numerator = sum_xy denominator = sqrt(sum_xx) * sqrt(sum_yy) score = 0 if (denominator): score = (numerator / (float(denominator))) return (score, numPairs) moviePairSimilarities = moviePairRatings.mapValues(cosineSimilarity).cache() moviePairSimilarities.takeOrdered(10, key = lambda x: x[0]) Explanation: Similar Movies Find similar movies for a given movie using cosine similarity End of explanation scoreThreshold = 0.97 coOccurenceThreshold = 50 inputMovieID = 1 #Toy Story. # Filter for movies with this sim that are "good" as defined by our quality thresholds. filteredResults = moviePairSimilarities.filter(lambda((pair,sim)): \ (pair[0] == inputMovieID or pair[1] == inputMovieID) and sim[0] > scoreThreshold and sim[1] > coOccurenceThreshold) #Top 10 by quality score. results = filteredResults.map(lambda((pair,sim)): (sim, pair)).sortByKey(ascending = False).take(10) print "Top 10 similar movies for " + nameDict[inputMovieID] for result in results: (sim, pair) = result # Display the similarity result that isn't the movie we're looking at similarMovieID = pair[0] if (similarMovieID == inputMovieID): similarMovieID = pair[1] print nameDict[similarMovieID] + "\tscore: " + str(sim[0]) + "\tstrength: " + str(sim[1]) Explanation: Lets find similar movies for Toy Story (Movie ID: 1) End of explanation ratings = data.map(lambda l: l.split()).map(lambda l: Rating(int(l[0]), int(l[1]), float(l[2]))).cache() ratings.take(3) nratings = ratings.count() nUsers = ratings.keys().distinct().count() nMovies = ratings.values().distinct().count() print "We have Got %d ratings from %d users on %d movies." % (nratings, nUsers, nMovies) # Build the recommendation model using Alternating Least Squares #Train a matrix factorization model given an RDD of ratings given by users to items, in the form of #(userID, itemID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices #of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. #The level of parallelism is determined automatically based on the number of partitions in ratings. start = time() seed = 5L iterations = 10 rank = 8 model = ALS.train(ratings, rank, iterations) duration = time() - start print "Model trained in %s seconds" % round(duration,3) Explanation: Recommender using MLLib Training the recommendation model End of explanation #Lets recommend movies for the user id - 2 userID = 2 print "\nTop 10 recommendations:" recommendations = model.recommendProducts(userID, 10) for recommendation in recommendations: print nameDict[int(recommendation[1])] + \ " score " + str(recommendation[2]) Explanation: Recommendations End of explanation
12,412	Given the following text description, write Python code to implement the functionality described below step by step Description: Contents Step1: 2. Millionaires What country are most billionaires from? For the top ones, how many billionaires per billion people? Step2: What's the average wealth of a billionaire? Male? Female? Step3: Who is the poorest billionaire? Who are the top 10 poorest billionaires? Step4: What is 'relationship to company'? And what are the most common relationships? Step5: Most common source of wealth? Male vs. female? Step6: Given the richest person in a country, what % of the GDP is their wealth? Step7: Trains stations	Python Code: import pandas as pd import matplotlib.pyplot as plt %matplotlib inline df = pd.read_csv("07-hw-animals.csv") df.columns df.head(3) df.sort_values(by='length', ascending=False).head(3) df['animal'].value_counts() dogs = df[df['animal']=='dog'] dogs df[df['length'] > 40] df['inches'] = .393701 * df['length'] df cats = df[df['animal']=='cat'] dogs = df[df['animal']=='dog'] # Display all of the animals that are cats and above 12 inches long. # First do it using the "cats" variable, then do it using your normal dataframe. cats[cats['inches'] > 12] df[(df['animal'] == 'cat') & (df['inches'] > 12)] cats['length'].describe()[['mean']] dogs['length'].describe()[['mean']] animals = df.groupby( [ "animal"] ) animals['length'].mean() plt.style.use('ggplot') dogs['length'].hist() labels = dogs['name'] sizes = dogs['length'] explode = (0.1, 0.2, 0.2) # fun plt.pie(sizes, explode=explode, labels=labels, autopct='%1.2f%%', shadow=True, startangle=30) #cf: recent.head().plot(kind='pie', y='networthusbillion', labels=recent['name'].head(), legend=False) #Make a horizontal bar graph of the length of the animals, with their name as the label df.plot(kind='barh', x='name', y='length', legend=False) #Make a sorted horizontal bar graph of the cats, with the larger cats on top. cats.sort_values(by='length').plot(kind='barh', x='name', y='length', legend=False) Explanation: Contents: 1 Cats and dogs 2 Millionaires 3 Trains stations 1. Cats and dogs End of explanation df2 = pd.read_excel("richpeople.xlsx") df2.keys() df2['citizenship'].value_counts().head(10) # population: data from http://data.worldbank.org/indicator/SP.POP.TOTL df_pop = pd.read_csv("world_pop.csv", header=2) df_pop.keys() #recent_pop = df_pop['2015'] #join: see http://pandas.pydata.org/pandas-docs/stable/merging.html#joining-on-index left = pd.DataFrame(df2, index=['countrycode']) right = pd.DataFrame(df_pop, index=['Country Code']) millionaires_and_pop = left.join(right) result = pd.merge(left, right, left_index=True, right_index=True, how='outer') millionaires_and_pop result #millionaires_and_pop['citizenship'].value_counts().head(10) Explanation: 2. Millionaires What country are most billionaires from? For the top ones, how many billionaires per billion people? End of explanation print("The average wealth of a billionaire (in billions) is:", df2['networthusbillion'].describe()['mean']) print("The average wealth of a male billionaire is:", df2[df2['gender'] == 'male']['networthusbillion'].describe()['mean']) print("The average wealth of a female billionaire is:", df2[df2['gender'] == 'female']['networthusbillion'].describe()['mean']) Explanation: What's the average wealth of a billionaire? Male? Female? End of explanation print('The poorest billionaire is:', df2.get_value(df2.sort_values('networthusbillion', ascending=True).index[0],'name')) df2.sort_values('networthusbillion', ascending=True).head(10) Explanation: Who is the poorest billionaire? Who are the top 10 poorest billionaires? End of explanation #relationship_values = set relationship_list = df2['relationshiptocompany'].tolist() relationship_set = set(relationship_list) relationship_set = [s.strip() for s in relationship_set if s == s] # to remove a naughty NaN and get rid of dumb whitespaces print("The relationships are:", str.join(', ', relationship_set)) print('\nThe five most common relationships are:') df2['relationshiptocompany'].value_counts().head(5) Explanation: What is 'relationship to company'? And what are the most common relationships? End of explanation print("The three most common sources of wealth are:\n" + str(df2['typeofwealth'].value_counts().head(3))) print("\nFor men, they are:\n" + str(df2[df2['gender'] == 'male']['typeofwealth'].value_counts().head(3))) print("\nFor women, they are:\n" + str(df2[df2['gender'] == 'female']['typeofwealth'].value_counts().head(3))) Explanation: Most common source of wealth? Male vs. female? End of explanation #per_country = df2.groupby(['citizenship']) #per_country['networthusbillion'].max() #per_country['networthusbillion'].idxmax() # DataFrame.max(axis=None, skipna=None, level=None, numeric_only=None, *kwargs) # per_country['gdpcurrentus'] df2['percofgdp'] = (1001000000000*df2['networthusbillion']) / (df2['gdpcurrentus']) #pd.Series(["{0:.2f}%".format(percofgdp)]) print("NB: most countries doesn't have their GDP in the 'gdpcurrentus' column.") df2.loc[per_country['networthusbillion'].idxmax()][['name', 'networthusbillion', 'percofgdp']] Explanation: Given the richest person in a country, what % of the GDP is their wealth? End of explanation df_trains = pd.read_csv("stations.csv", delimiter=';') df_trains Explanation: Trains stations End of explanation
12,413	Given the following text description, write Python code to implement the functionality described below step by step Description: <div class="alert alert-block alert-info" style="margin-top Step1: <a id="ref0"></a> <h2> Helper Functions </h2> Functions used to plot Step2: dataset object Step3: <a id='ref1'> </a> <h2>Neural Network Module and Function for Training </h2> Neural Network Module using <code> ModuleList() </code> Step4: A function used to train. Step5: A function used to calculate accuracy Step6: <a id="ref2"></a> <h2>Train and Validate the Model </h2> Crate a dataset object Step7: Create a network to classify three classes with 1 hidden layer with 50 neurons Step8: Create a network to classify three classes with 2 hidden layer with 20 neurons	Python Code: import matplotlib.pyplot as plt import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from matplotlib.colors import ListedColormap torch.manual_seed(1) Explanation: <div class="alert alert-block alert-info" style="margin-top: 20px"> <a href="http://cocl.us/NotebooksPython101"><img src = "https://ibm.box.com/shared/static/yfe6h4az47ktg2mm9h05wby2n7e8kei3.png" width = 750, align = "center"></a> <img src = "https://ibm.box.com/shared/static/ugcqz6ohbvff804xp84y4kqnvvk3bq1g.png" width = 200, align = "center"> <h1 align=center><font size = 5>Deeper Neural Networks with nn.ModuleList() </font></h1> # Table of Contents In this lab, you will go over the basics of tensor operations <div class="alert alert-block alert-info" style="margin-top: 20px"> <li><a href="#ref0">Helper Functions </a></li> <li><a href="#ref1">Neural Network Module and Function for Training</a></li> <li><a href="#ref2"> Train and Validate the Model <a></li> <li><a href="#ref3">Practice Question</a></li> <br> <p></p> Estimated Time Needed: <strong>25 min</strong> </div> <hr> You'll need the following libraries: End of explanation def plot_decision_regions_3class(model,data_set): cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA','#00AAFF']) cmap_bold = ListedColormap(['#FF0000', '#00FF00','#00AAFF']) X=data_set.x.numpy() y=data_set.y.numpy() h = .02 x_min, x_max = X[:, 0].min()-0.1 , X[:, 0].max()+0.1 y_min, y_max = X[:, 1].min()-0.1 , X[:, 1].max() +0.1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h)) XX=torch.torch.Tensor(np.c_[xx.ravel(), yy.ravel()]) _,yhat=torch.max(model(XX),1) yhat=yhat.numpy().reshape(xx.shape) plt.pcolormesh(xx, yy, yhat, cmap=cmap_light) plt.plot(X[y[:]==0,0],X[y[:]==0,1],'ro',label='y=0') plt.plot(X[y[:]==1,0],X[y[:]==1,1],'go',label='y=1') plt.plot(X[y[:]==2,0],X[y[:]==2,1],'o',label='y=2') plt.title("decision region") plt.legend() Explanation: <a id="ref0"></a> <h2> Helper Functions </h2> Functions used to plot: End of explanation from torch.utils.data import Dataset, DataLoader class Data(Dataset): # modified from: http://cs231n.github.io/neural-networks-case-study/ def __init__(self,K=3,N=500): D = 2 X = np.zeros((NK,D)) # data matrix (each row = single example) y = np.zeros(NK, dtype='uint8') # class labels for j in range(K): ix = range(Nj,N(j+1)) r = np.linspace(0.0,1,N) # radius t = np.linspace(j4,(j+1)4,N) + np.random.randn(N)0.2 # theta X[ix] = np.c_[rnp.sin(t), r*np.cos(t)] y[ix] = j self.y=torch.from_numpy(y).type(torch.LongTensor) self.x=torch.from_numpy(X).type(torch.FloatTensor) self.len=y.shape[0] def __getitem__(self,index): return self.x[index],self.y[index] def __len__(self): return self.len def plot_stuff(self): plt.plot(self.x[self.y[:]==0,0].numpy(),self.x[self.y[:]==0,1].numpy(),'o',label="y=0") plt.plot(self.x[self.y[:]==1,0].numpy(),self.x[self.y[:]==1,1].numpy(),'ro',label="y=1") plt.plot(self.x[self.y[:]==2,0].numpy(),self.x[self.y[:]==2,1].numpy(),'go',label="y=2") plt.legend() Explanation: dataset object End of explanation class Net(nn.Module): def __init__(self,Layers): super(Net,self).__init__() self.hidden = nn.ModuleList() for input_size,output_size in zip(Layers,Layers[1:]): self.hidden.append(nn.Linear(input_size,output_size)) def forward(self,activation): L=len(self.hidden) for (l,linear_transform) in zip(range(L),self.hidden): if l<L-1: activation =F.relu(linear_transform (activation)) else: activation =linear_transform (activation) return activation Explanation: <a id='ref1'> </a> <h2>Neural Network Module and Function for Training </h2> Neural Network Module using <code> ModuleList() </code> End of explanation def train(data_set,model,criterion, train_loader, optimizer, epochs=100): LOSS=[] ACC=[] for epoch in range(epochs): for x,y in train_loader: optimizer.zero_grad() yhat=model(x) loss=criterion(yhat,y) optimizer.zero_grad() loss.backward() optimizer.step() LOSS.append(loss.item()) ACC.append(accuracy(model,data_set)) fig, ax1 = plt.subplots() color = 'tab:red' ax1.plot(LOSS,color=color) ax1.set_xlabel('epoch',color=color) ax1.set_ylabel('total loss',color=color) ax1.tick_params(axis='y', color=color) ax2 = ax1.twinx() color = 'tab:blue' ax2.set_ylabel('accuracy', color=color) # we already handled the x-label with ax1 ax2.plot( ACC, color=color) ax2.tick_params(axis='y', labelcolor=color) fig.tight_layout() # otherwise the right y-label is slightly clipped plt.show() return LOSS Explanation: A function used to train. End of explanation def accuracy(model,data_set): _,yhat=torch.max(model(data_set.x),1) return (yhat==data_set.y).numpy().mean() Explanation: A function used to calculate accuracy End of explanation data_set=Data() data_set.plot_stuff() data_set.y=data_set.y.view(-1) Explanation: <a id="ref2"></a> <h2>Train and Validate the Model </h2> Crate a dataset object: End of explanation Layers=[2,50,3] model=Net(Layers) learning_rate=0.10 optimizer=torch.optim.SGD(model.parameters(), lr=learning_rate) train_loader=DataLoader(dataset=data_set,batch_size=20) criterion=nn.CrossEntropyLoss() LOSS=train(data_set,model,criterion, train_loader, optimizer, epochs=100) plot_decision_regions_3class(model,data_set) Explanation: Create a network to classify three classes with 1 hidden layer with 50 neurons End of explanation Layers=[2,10,10,3] model=Net(Layers) learning_rate=0.01 optimizer=torch.optim.SGD(model.parameters(), lr=learning_rate) train_loader=DataLoader(dataset=data_set,batch_size=20) criterion=nn.CrossEntropyLoss() LOSS=train(data_set,model,criterion, train_loader, optimizer, epochs=1000) plot_decision_regions_3class(model,data_set) Explanation: Create a network to classify three classes with 2 hidden layer with 20 neurons End of explanation
12,414	Given the following text description, write Python code to implement the functionality described below step by step Description: Step1: Face Generation In this project, you'll use generative adversarial networks to generate new images of faces. Get the Data You'll be using two datasets in this project Step3: Explore the Data MNIST As you're aware, the MNIST dataset contains images of handwritten digits. You can view the first number of examples by changing show_n_images. Step5: CelebA The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images. Step7: Preprocess the Data Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28. The MNIST images are black and white images with a single [color channel](https Step10: Input Implement the model_inputs function to create TF Placeholders for the Neural Network. It should create the following placeholders Step13: Discriminator Implement discriminator to create a discriminator neural network that discriminates on images. This function should be able to reuse the variabes in the neural network. Use tf.variable_scope with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the generator, tensor logits of the generator). Step16: Generator Implement generator to generate an image using z. This function should be able to reuse the variabes in the neural network. Use tf.variable_scope with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim images. Step19: Loss Implement model_loss to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented Step22: Optimization Implement model_opt to create the optimization operations for the GANs. Use tf.trainable_variables to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation). Step25: Neural Network Training Show Output Use this function to show the current output of the generator during training. It will help you determine how well the GANs is training. Step27: Train Implement train to build and train the GANs. Use the following functions you implemented Step29: MNIST Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0. Step31: CelebA Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces.	Python Code: data_dir = './data' # FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe" #data_dir = '/input/R5KrjnANiKVhLWAkpXhNBe' import time import pylab as pl from IPython import display DON'T MODIFY ANYTHING IN THIS CELL import helper helper.download_extract('mnist', data_dir) helper.download_extract('celeba', data_dir) Explanation: Face Generation In this project, you'll use generative adversarial networks to generate new images of faces. Get the Data You'll be using two datasets in this project: - MNIST - CelebA Since the celebA dataset is complex and you're doing GANs in a project for the first time, we want you to test your neural network on MNIST before CelebA. Running the GANs on MNIST will allow you to see how well your model trains sooner. If you're using FloydHub, set data_dir to "/input" and use the FloydHub data ID "R5KrjnANiKVhLWAkpXhNBe". End of explanation show_n_images = 25 DON'T MODIFY ANYTHING IN THIS CELL %matplotlib inline import os from glob import glob from matplotlib import pyplot mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/.jpg'))[:show_n_images], 28, 28, 'L') pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray') Explanation: Explore the Data MNIST As you're aware, the MNIST dataset contains images of handwritten digits. You can view the first number of examples by changing show_n_images. End of explanation show_n_images = 25 DON'T MODIFY ANYTHING IN THIS CELL mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'img_align_celeba/.jpg'))[:show_n_images], 28, 28, 'RGB') pyplot.imshow(helper.images_square_grid(mnist_images, 'RGB')) Explanation: CelebA The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images. End of explanation DON'T MODIFY ANYTHING IN THIS CELL from distutils.version import LooseVersion import warnings import tensorflow as tf # Check TensorFlow Version assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer. You are using {}'.format(tf.__version__) print('TensorFlow Version: {}'.format(tf.__version__)) # Check for a GPU if not tf.test.gpu_device_name(): warnings.warn('No GPU found. Please use a GPU to train your neural network.') else: print('Default GPU Device: {}'.format(tf.test.gpu_device_name())) Explanation: Preprocess the Data Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28. The MNIST images are black and white images with a single [color channel](https://en.wikipedia.org/wiki/Channel_(digital_image%29) while the CelebA images have [3 color channels (RGB color channel)](https://en.wikipedia.org/wiki/Channel_(digital_image%29#RGB_Images). Build the Neural Network You'll build the components necessary to build a GANs by implementing the following functions below: - model_inputs - discriminator - generator - model_loss - model_opt - train Check the Version of TensorFlow and Access to GPU This will check to make sure you have the correct version of TensorFlow and access to a GPU End of explanation import problem_unittests as tests def model_inputs(image_width, image_height, image_channels, z_dim): Create the model inputs :param image_width: The input image width :param image_height: The input image height :param image_channels: The number of image channels :param z_dim: The dimension of Z :return: Tuple of (tensor of real input images, tensor of z data, learning rate) return tf.placeholder(tf.float32, [None, image_width, image_height, image_channels], name='input'),\ tf.placeholder(tf.float32, [None, z_dim], name='z_input'),\ tf.placeholder(tf.float32, name='learn_rate') DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE tests.test_model_inputs(model_inputs) Explanation: Input Implement the model_inputs function to create TF Placeholders for the Neural Network. It should create the following placeholders: - Real input images placeholder with rank 4 using image_width, image_height, and image_channels. - Z input placeholder with rank 2 using z_dim. - Learning rate placeholder with rank 0. Return the placeholders in the following the tuple (tensor of real input images, tensor of z data) End of explanation def discriminator(images, reuse=False, n_units=128, alpha=0.2): Create the discriminator network :param image: Tensor of input image(s) :param reuse: Boolean if the weights should be reused :return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator) with tf.variable_scope('discriminator', reuse=reuse): x1 = tf.layers.conv2d(images, 64, 5, strides=2, padding='same') relu1 = tf.maximum(alpha * x1, x1) x2 = tf.layers.conv2d(relu1, 128, 5, strides=2, padding='same') bn2 = tf.layers.batch_normalization(x2, training=True) relu2 = tf.maximum(alpha * bn2, bn2) x3 = tf.layers.conv2d(relu2, 256, 5, strides=2, padding='same') bn3 = tf.layers.batch_normalization(x3, training=True) relu3 = tf.maximum(alpha * bn3, bn3) x4 = tf.layers.conv2d(relu3, 512, 5, strides=2, padding='same') bn4 = tf.layers.batch_normalization(x4, training=True) relu4 = tf.maximum(alpha * bn4, bn4) logits = tf.layers.dense(tf.reshape(relu4, (-1, 44512)), 1) out = tf.sigmoid(logits) return out, logits DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE tests.test_discriminator(discriminator, tf) Explanation: Discriminator Implement discriminator to create a discriminator neural network that discriminates on images. This function should be able to reuse the variabes in the neural network. Use tf.variable_scope with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the generator, tensor logits of the generator). End of explanation def generator(z, out_channel_dim, is_train=True, alpha = 0.1): Create the generator network :param z: Input z :param out_channel_dim: The number of channels in the output image :param is_train: Boolean if generator is being used for training :return: The tensor output of the generator with tf.variable_scope('generator', reuse=not is_train): # First fully connected layer x1 = tf.layers.dense(z, 77512) x1 = tf.reshape(x1, (-1, 7, 7, 512)) x1 = tf.layers.batch_normalization(x1, training=is_train) x1 = tf.maximum(alpha * x1, x1) x1 = tf.reshape(x1, (-1, 7, 7, 256)) x1 = tf.layers.batch_normalization(x1, training=is_train) x1 = tf.maximum(alpha * x1, x1) x2 = tf.layers.conv2d_transpose(x1, 128, 5, strides=1, padding='same') x2 = tf.layers.batch_normalization(x2, training=is_train) x2 = tf.maximum(alpha * x2, x2) x3 = tf.layers.conv2d_transpose(x2, 64, 5, strides=2, padding='same') x3 = tf.layers.batch_normalization(x3, training=is_train) x3 = tf.maximum(alpha * x3, x3) # Output layer logits = tf.layers.conv2d_transpose(x3, out_channel_dim, 5, strides=2, padding='same') return tf.tanh(logits) DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE tests.test_generator(generator, tf) Explanation: Generator Implement generator to generate an image using z. This function should be able to reuse the variabes in the neural network. Use tf.variable_scope with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim images. End of explanation def model_loss(input_real, input_z, out_channel_dim): Get the loss for the discriminator and generator :param input_real: Images from the real dataset :param input_z: Z input :param out_channel_dim: The number of channels in the output image :return: A tuple of (discriminator loss, generator loss) gen = generator(input_z, out_channel_dim) disc_real, disc_logits_real = discriminator(input_real) disc_fake, disc_logits_fake = discriminator(gen, reuse=True) disc_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=disc_logits_real, \ labels=tf.ones_like(disc_real)0.9)) disc_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=disc_logits_fake, \ labels=tf.zeros_like(disc_fake))) gen_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=disc_logits_fake, \ labels=tf.ones_like(disc_fake))) disc_loss = disc_loss_real + disc_loss_fake return disc_loss, gen_loss DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE tests.test_model_loss(model_loss) Explanation: Loss Implement model_loss to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented: - discriminator(images, reuse=False) - generator(z, out_channel_dim, is_train=True) End of explanation def model_opt(d_loss, g_loss, learning_rate, beta1): Get optimization operations :param d_loss: Discriminator loss Tensor :param g_loss: Generator loss Tensor :param learning_rate: Learning Rate Placeholder :param beta1: The exponential decay rate for the 1st moment in the optimizer :return: A tuple of (discriminator training operation, generator training operation) trainable_variables = tf.trainable_variables() d_vars = [var for var in trainable_variables if var.name.startswith('discriminator')] g_vars = [var for var in trainable_variables if var.name.startswith('generator')] with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): return tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(d_loss, var_list=d_vars), \ tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(g_loss, var_list=g_vars) DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE tests.test_model_opt(model_opt, tf) Explanation: Optimization Implement model_opt to create the optimization operations for the GANs. Use tf.trainable_variables to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation). End of explanation DON'T MODIFY ANYTHING IN THIS CELL import numpy as np def show_generator_output(sess, n_images, input_z, out_channel_dim, image_mode): Show example output for the generator :param sess: TensorFlow session :param n_images: Number of Images to display :param input_z: Input Z Tensor :param out_channel_dim: The number of channels in the output image :param image_mode: The mode to use for images ("RGB" or "L") cmap = None if image_mode == 'RGB' else 'gray' z_dim = input_z.get_shape().as_list()[-1] example_z = np.random.uniform(-1, 1, size=[n_images, z_dim]) samples = sess.run( generator(input_z, out_channel_dim, False), feed_dict={input_z: example_z}) images_grid = helper.images_square_grid(samples, image_mode) pyplot.imshow(images_grid, cmap=cmap) pyplot.show() Explanation: Neural Network Training Show Output Use this function to show the current output of the generator during training. It will help you determine how well the GANs is training. End of explanation def plot_losses_graph(steps, gen_loss, disc_loss): pl.ylim(min(min(gen_loss), min(disc_loss)), 2) pl.xlim(min(steps), max(steps)) pl.plot(steps, gen_loss, label = 'Generator Loss', color = 'green') pl.plot(steps, disc_loss, label = 'Discriminator Loss', color = 'red') pl.legend(loc='upper right') pl.xlabel('Steps') display.clear_output(wait=True) display.display(pl.gcf()) pl.gcf().clear() time.sleep(0.1) def train(epoch_count, batch_size, z_dim, learning_rate, beta1, get_batches, data_shape, data_image_mode): Train the GAN :param epoch_count: Number of epochs :param batch_size: Batch Size :param z_dim: Z dimension :param learning_rate: Learning Rate :param beta1: The exponential decay rate for the 1st moment in the optimizer :param get_batches: Function to get batches :param data_shape: Shape of the data :param data_image_mode: The image mode to use for images ("RGB" or "L") image_channels = 3 if data_image_mode == 'RGB' else 1 input_real, input_z, _ = model_inputs(data_shape[1], data_shape[2], data_shape[3], z_dim) d_loss, g_loss = model_loss(input_real, input_z, data_shape[3]) d_opt, g_opt = model_opt(d_loss, g_loss, learning_rate, beta1) steps = 0 samples, losses = [], [] steps_list, gen_loss, disc_loss = [], [], [] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch_i in range(epoch_count): for batch_images in get_batches(batch_size): batch_images = batch_images 2 batch_z = np.random.uniform(-1, 1, size=(batch_size, z_dim)) _ = sess.run(d_opt, feed_dict={input_real: batch_images, input_z: batch_z}) _ = sess.run(g_opt, feed_dict={input_real: batch_images, input_z: batch_z}) _ = sess.run(g_opt, feed_dict={input_real: batch_images, input_z: batch_z}) steps += 1 if steps % 10 == 0: # At the end of each epoch, get the losses and print them out train_loss_d = d_loss.eval({input_z: batch_z, input_real: batch_images}) train_loss_g = g_loss.eval({input_z: batch_z}) steps_list.append(steps/10) gen_loss.append(train_loss_g) disc_loss.append(train_loss_d) plot_losses_graph(steps_list, gen_loss, disc_loss) print('Epoch {}/{} - Step {}: Discriminator Loss - {:>3.3f}, Generator Loss - {:>3.3f}'\ .format(epoch_i+1, epoch_count, steps, train_loss_d, train_loss_g)) # Save losses to view after training losses.append((train_loss_d, train_loss_g)) show_generator_output(sess, 9, input_z, data_shape[3], data_image_mode) Explanation: Train Implement train to build and train the GANs. Use the following functions you implemented: - model_inputs(image_width, image_height, image_channels, z_dim) - model_loss(input_real, input_z, out_channel_dim) - model_opt(d_loss, g_loss, learning_rate, beta1) Use the show_generator_output to show generator output while you train. Running show_generator_output for every batch will drastically increase training time and increase the size of the notebook. It's recommended to print the generator output every 100 batches. End of explanation batch_size = 64 z_dim = 100 learning_rate = 0.0002 beta1 = 0.5 DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE epochs = 20 mnist_dataset = helper.Dataset('mnist', glob(os.path.join(data_dir, 'mnist/.jpg'))) with tf.Graph().as_default(): train(epochs, batch_size, z_dim, learning_rate, beta1, mnist_dataset.get_batches, mnist_dataset.shape, mnist_dataset.image_mode) Explanation: MNIST Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0. End of explanation DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE epochs = 3 celeba_dataset = helper.Dataset('celeba', glob(os.path.join(data_dir, 'img_align_celeba/.jpg'))) with tf.Graph().as_default(): train(epochs, batch_size, z_dim, learning_rate, beta1, celeba_dataset.get_batches, celeba_dataset.shape, celeba_dataset.image_mode) Explanation: CelebA Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces. End of explanation
12,415	Given the following text description, write Python code to implement the functionality described below step by step Description: Hadamard Multitask GP Regression Introduction This notebook demonstrates how to perform "Hadamard" multitask regression. This differs from the multitask gp regression example notebook in one key way Step1: Set up training data In the next cell, we set up the training data for this example. For each task we'll be using 50 random points on [0,1), which we evaluate the function on and add Gaussian noise to get the training labels. Note that different inputs are used for each task. We'll have two functions - a sine function (y1) and a cosine function (y2). Step2: Set up a Hadamard multitask model The model should be somewhat similar to the ExactGP model in the simple regression example. The differences Step3: Training the model In the next cell, we handle using Type-II MLE to train the hyperparameters of the Gaussian process. See the simple regression example for more info on this step. Step4: Make predictions with the model	Python Code: import math import torch import gpytorch from matplotlib import pyplot as plt %matplotlib inline %load_ext autoreload %autoreload 2 Explanation: Hadamard Multitask GP Regression Introduction This notebook demonstrates how to perform "Hadamard" multitask regression. This differs from the multitask gp regression example notebook in one key way: Here, we assume that we have observations for one task per input. For each input, we specify the task of the input that we observe. (The kernel that we learn is expressed as a Hadamard product of an input kernel and a task kernel) In the other notebook, we assume that we observe all tasks per input. (The kernel in that notebook is the Kronecker product of an input kernel and a task kernel). Multitask regression, first introduced in this paper learns similarities in the outputs simultaneously. It's useful when you are performing regression on multiple functions that share the same inputs, especially if they have similarities (such as being sinusodial). Given inputs $x$ and $x'$, and tasks $i$ and $j$, the covariance between two datapoints and two tasks is given by $$ k([x, i], [x', j]) = k_\text{inputs}(x, x') * k_\text{tasks}(i, j) $$ where $k_\text{inputs}$ is a standard kernel (e.g. RBF) that operates on the inputs. $k_\text{task}$ is a special kernel - the IndexKernel - which is a lookup table containing inter-task covariance. End of explanation train_x1 = torch.rand(50) train_x2 = torch.rand(50) train_y1 = torch.sin(train_x1 * (2 * math.pi)) + torch.randn(train_x1.size()) * 0.2 train_y2 = torch.cos(train_x2 * (2 * math.pi)) + torch.randn(train_x2.size()) * 0.2 Explanation: Set up training data In the next cell, we set up the training data for this example. For each task we'll be using 50 random points on [0,1), which we evaluate the function on and add Gaussian noise to get the training labels. Note that different inputs are used for each task. We'll have two functions - a sine function (y1) and a cosine function (y2). End of explanation class MultitaskGPModel(gpytorch.models.ExactGP): def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = gpytorch.means.ConstantMean() self.covar_module = gpytorch.kernels.RBFKernel() # We learn an IndexKernel for 2 tasks # (so we'll actually learn 2x2=4 tasks with correlations) self.task_covar_module = gpytorch.kernels.IndexKernel(num_tasks=2, rank=1) def forward(self,x,i): mean_x = self.mean_module(x) # Get input-input covariance covar_x = self.covar_module(x) # Get task-task covariance covar_i = self.task_covar_module(i) # Multiply the two together to get the covariance we want covar = covar_x.mul(covar_i) return gpytorch.distributions.MultivariateNormal(mean_x, covar) likelihood = gpytorch.likelihoods.GaussianLikelihood() train_i_task1 = torch.full_like(train_x1, dtype=torch.long, fill_value=0) train_i_task2 = torch.full_like(train_x2, dtype=torch.long, fill_value=1) full_train_x = torch.cat([train_x1, train_x2]) full_train_i = torch.cat([train_i_task1, train_i_task2]) full_train_y = torch.cat([train_y1, train_y2]) # Here we have two iterms that we're passing in as train_inputs model = MultitaskGPModel((full_train_x, full_train_i), full_train_y, likelihood) Explanation: Set up a Hadamard multitask model The model should be somewhat similar to the ExactGP model in the simple regression example. The differences: The model takes two input: the inputs (x) and indices. The indices indicate which task the observation is for. Rather than just using a RBFKernel, we're using that in conjunction with a IndexKernel. We don't use a ScaleKernel, since the IndexKernel will do some scaling for us. (This way we're not overparameterizing the kernel.) End of explanation # this is for running the notebook in our testing framework import os smoke_test = ('CI' in os.environ) training_iterations = 2 if smoke_test else 50 # Find optimal model hyperparameters model.train() likelihood.train() # Use the adam optimizer optimizer = torch.optim.Adam(model.parameters(), lr=0.1) # Includes GaussianLikelihood parameters # "Loss" for GPs - the marginal log likelihood mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) for i in range(training_iterations): optimizer.zero_grad() output = model(full_train_x, full_train_i) loss = -mll(output, full_train_y) loss.backward() print('Iter %d/50 - Loss: %.3f' % (i + 1, loss.item())) optimizer.step() Explanation: Training the model In the next cell, we handle using Type-II MLE to train the hyperparameters of the Gaussian process. See the simple regression example for more info on this step. End of explanation # Set into eval mode model.eval() likelihood.eval() # Initialize plots f, (y1_ax, y2_ax) = plt.subplots(1, 2, figsize=(8, 3)) # Test points every 0.02 in [0,1] test_x = torch.linspace(0, 1, 51) tast_i_task1 = torch.full_like(test_x, dtype=torch.long, fill_value=0) test_i_task2 = torch.full_like(test_x, dtype=torch.long, fill_value=1) # Make predictions - one task at a time # We control the task we cae about using the indices # The gpytorch.settings.fast_pred_var flag activates LOVE (for fast variances) # See https://arxiv.org/abs/1803.06058 with torch.no_grad(), gpytorch.settings.fast_pred_var(): observed_pred_y1 = likelihood(model(test_x, tast_i_task1)) observed_pred_y2 = likelihood(model(test_x, test_i_task2)) # Define plotting function def ax_plot(ax, train_y, train_x, rand_var, title): # Get lower and upper confidence bounds lower, upper = rand_var.confidence_region() # Plot training data as black stars ax.plot(train_x.detach().numpy(), train_y.detach().numpy(), 'k*') # Predictive mean as blue line ax.plot(test_x.detach().numpy(), rand_var.mean.detach().numpy(), 'b') # Shade in confidence ax.fill_between(test_x.detach().numpy(), lower.detach().numpy(), upper.detach().numpy(), alpha=0.5) ax.set_ylim([-3, 3]) ax.legend(['Observed Data', 'Mean', 'Confidence']) ax.set_title(title) # Plot both tasks ax_plot(y1_ax, train_y1, train_x1, observed_pred_y1, 'Observed Values (Likelihood)') ax_plot(y2_ax, train_y2, train_x2, observed_pred_y2, 'Observed Values (Likelihood)') Explanation: Make predictions with the model End of explanation
12,416	Given the following text description, write Python code to implement the functionality described below step by step Description: Ordinary Differential Equations Exercise 3 Imports Step1: Damped, driven nonlinear pendulum The equations of motion for a simple pendulum of mass $m$, length $l$ are Step4: Write a function derivs for usage with scipy.integrate.odeint that computes the derivatives for the damped, driven harmonic oscillator. The solution vector at each time will be $\vec{y}(t) = (\theta(t),\omega(t))$. Step5: Simple pendulum Use the above functions to integrate the simple pendulum for the case where it starts at rest pointing vertically upwards. In this case, it should remain at rest with constant energy. Integrate the equations of motion. Plot $E/m$ versus time. Plot $\theta(t)$ and $\omega(t)$ versus time. Tune the atol and rtol arguments of odeint until $E/m$, $\theta(t)$ and $\omega(t)$ are constant. Anytime you have a differential equation with a a conserved quantity, it is critical to make sure the numerical solutions conserve that quantity as well. This also gives you an opportunity to find other bugs in your code. The default error tolerances (atol and rtol) used by odeint are not sufficiently small for this problem. Start by trying atol=1e-3, rtol=1e-2 and then decrease each by an order of magnitude until your solutions are stable. Step7: Damped pendulum Write a plot_pendulum function that integrates the damped, driven pendulum differential equation for a particular set of parameters $[a,b,\omega_0]$. Use the initial conditions $\theta(0)=-\pi + 0.1$ and $\omega=0$. Decrease your atol and rtol even futher and make sure your solutions have converged. Make a parametric plot of $[\theta(t),\omega(t)]$ versus time. Use the plot limits $\theta \in [-2 \pi,2 \pi]$ and $\theta \in [-10,10]$ Label your axes and customize your plot to make it beautiful and effective. Step8: Here is an example of the output of your plot_pendulum function that should show a decaying spiral. Step9: Use interact to explore the plot_pendulum function with	Python Code: %matplotlib inline import matplotlib.pyplot as plt import numpy as np import seaborn as sns from scipy.integrate import odeint from IPython.html.widgets import interact, fixed Explanation: Ordinary Differential Equations Exercise 3 Imports End of explanation g = 9.81 # m/s^2 l = 0.5 # length of pendulum, in meters tmax = 50. # seconds t = np.linspace(0, tmax, int(100tmax)) Explanation: Damped, driven nonlinear pendulum The equations of motion for a simple pendulum of mass $m$, length $l$ are: $$ \frac{d^2\theta}{dt^2} = \frac{-g}{\ell}\sin\theta $$ When a damping and periodic driving force are added the resulting system has much richer and interesting dynamics: $$ \frac{d^2\theta}{dt^2} = \frac{-g}{\ell}\sin\theta - a \omega - b \sin(\omega_0 t) $$ In this equation: $a$ governs the strength of the damping. $b$ governs the strength of the driving force. $\omega_0$ is the angular frequency of the driving force. When $a=0$ and $b=0$, the energy/mass is conserved: $$E/m =g\ell(1-\cos(\theta)) + \frac{1}{2}\ell^2\omega^2$$ Basic setup Here are the basic parameters we are going to use for this exercise: End of explanation def derivs(y, t, a, b, omega0): Compute the derivatives of the damped, driven pendulum. Parameters ---------- y : ndarray The solution vector at the current time t[i]: [theta[i],omega[i]]. t : float The current time t[i]. a, b, omega0: float The parameters in the differential equation. Returns ------- dy : ndarray The vector of derviatives at t[i]: [dtheta[i],domega[i]]. # YOUR CODE HERE raise NotImplementedError() assert np.allclose(derivs(np.array([np.pi,1.0]), 0, 1.0, 1.0, 1.0), [1.,-1.]) def energy(y): Compute the energy for the state array y. The state array y can have two forms: 1. It could be an ndim=1 array of np.array([theta,omega]) at a single time. 2. It could be an ndim=2 array where each row is the [theta,omega] at single time. Parameters ---------- y : ndarray, list, tuple A solution vector Returns ------- E/m : float (ndim=1) or ndarray (ndim=2) The energy per mass. # YOUR CODE HERE raise NotImplementedError() assert np.allclose(energy(np.array([np.pi,0])),g) assert np.allclose(energy(np.ones((10,2))), np.ones(10)energy(np.array([1,1]))) Explanation: Write a function derivs for usage with scipy.integrate.odeint that computes the derivatives for the damped, driven harmonic oscillator. The solution vector at each time will be $\vec{y}(t) = (\theta(t),\omega(t))$. End of explanation # YOUR CODE HERE raise NotImplementedError() # YOUR CODE HERE raise NotImplementedError() # YOUR CODE HERE raise NotImplementedError() assert True # leave this to grade the two plots and their tuning of atol, rtol. Explanation: Simple pendulum Use the above functions to integrate the simple pendulum for the case where it starts at rest pointing vertically upwards. In this case, it should remain at rest with constant energy. Integrate the equations of motion. Plot $E/m$ versus time. Plot $\theta(t)$ and $\omega(t)$ versus time. Tune the atol and rtol arguments of odeint until $E/m$, $\theta(t)$ and $\omega(t)$ are constant. Anytime you have a differential equation with a a conserved quantity, it is critical to make sure the numerical solutions conserve that quantity as well. This also gives you an opportunity to find other bugs in your code. The default error tolerances (atol and rtol) used by odeint are not sufficiently small for this problem. Start by trying atol=1e-3, rtol=1e-2 and then decrease each by an order of magnitude until your solutions are stable. End of explanation def plot_pendulum(a=0.0, b=0.0, omega0=0.0): Integrate the damped, driven pendulum and make a phase plot of the solution. # YOUR CODE HERE raise NotImplementedError() Explanation: Damped pendulum Write a plot_pendulum function that integrates the damped, driven pendulum differential equation for a particular set of parameters $[a,b,\omega_0]$. Use the initial conditions $\theta(0)=-\pi + 0.1$ and $\omega=0$. Decrease your atol and rtol even futher and make sure your solutions have converged. Make a parametric plot of $[\theta(t),\omega(t)]$ versus time. Use the plot limits $\theta \in [-2 \pi,2 \pi]$ and $\theta \in [-10,10]$ Label your axes and customize your plot to make it beautiful and effective. End of explanation plot_pendulum(0.5, 0.0, 0.0) Explanation: Here is an example of the output of your plot_pendulum function that should show a decaying spiral. End of explanation # YOUR CODE HERE raise NotImplementedError() Explanation: Use interact to explore the plot_pendulum function with: a: a float slider over the interval $[0.0,1.0]$ with steps of $0.1$. b: a float slider over the interval $[0.0,10.0]$ with steps of $0.1$. omega0: a float slider over the interval $[0.0,10.0]$ with steps of $0.1$. End of explanation
12,417	Given the following text description, write Python code to implement the functionality described below step by step Description: Astropy quantities Astropy quantitites are a great way to handle all sorts of messy unit conversions. Careful unit conversions save lives! https Step1: A brief word of warning, the pretty printing shown above will take longer than just printing out the values of an array. This is unnoticable in this case, but is evident if you try to print a large array of quantities. Step2: Constants Physical constants are found in the astropy.constants module, and work just like units. Step3: Calculations with quantity arrays Step4: Quantities as sanity checks Step5: Unit equivalencies Equivalencies allow you to do unit conversions under certain physical assumptions. For instance, it makes sense to talk about converting wavelength to frequency when you are discussing the properties of light waves in a vacuum. See http Step6: Spectral energy density equivalencies Step7: Other cool equivalencies Doppler shifts (for both radio velocities and optical velocities), dimensionless angles, parallax. Words of warning Quantity arrays will often break functions that aren't prepared for them. Simple numpy operations still work, but for more complicated routines you'll have to convert to the units you want and then take the underlying array with the quantity.value attribute. Step8: Even when you think you have a dimensionless array, it can still be a dimensionless quantity. Step9: Using units in your own code You can use the decorator quality_input as a clean way of ensuring your functions get the proper input. Step10: SkyCoord The SkyCoord class, from astropy.coordinates, is a convenient way of dealing with astronomical coordinate systems. http Step11: The attributes ra and dec are Angles. They are subclasses of Quantity, and so they behave similarly, but have more specific functionality. See http Step12: Matching coordinates There are lots of specific use cases outlined here, but let's go over a simple catalog matching exercise.	Python Code: print(type(u.Msun)) u.Msun Explanation: Astropy quantities Astropy quantitites are a great way to handle all sorts of messy unit conversions. Careful unit conversions save lives! https://en.wikipedia.org/wiki/Gimli_Glider The simplest way to create a new quantity object is multiply or divide a number by a Unit instance. End of explanation mass = 1 * u.Msun print(type(mass)) mass # quantities subclass numpy ndarray, so you can make handle arrays of quantities like you would # any other array object mass.__class__.__bases__ # we can convert units to other equivalent units mass.to(u.kg) # there are shortcuts for converting to the relevent system, regardless of what type of quantity it is mass.cgs mass.si # we can inspect their unit and their numeric value with that unit print(mass.value, mass.unit) # calculations with quantities can produce quantities with new units average_density = mass / (4 / 3 * np.pi * u.Rearth ** 3) average_density.cgs Explanation: A brief word of warning, the pretty printing shown above will take longer than just printing out the values of an array. This is unnoticable in this case, but is evident if you try to print a large array of quantities. End of explanation # Newton's constant c.G # Planck's constant c.h # speed of light c.c Explanation: Constants Physical constants are found in the astropy.constants module, and work just like units. End of explanation # made into a quantity array by multiplying numeric array by unit R = np.linspace(1, 5) * u.Rearth v = np.sqrt(2 * c.G * u.Msun / R) print(v) v = v.to(u.km / u.s) print(v) plt.plot(R, v) plt.xlabel(r"Radius [R$_\oplus$]") plt.ylabel(r"Escape velocity [km s$^{-1}$]") Explanation: Calculations with quantity arrays End of explanation obscure_quantity = 42 * c.G * c.m_e 2 / c.k_B 2 * c.c ** 3 * (5700 * u.K) ** -2 * u.Msun / u.Mpc obscure_quantity # what the heck is a m^6 kg Msun / (Mpc J^2 s^5)?? obscure_quantity.decompose() # will fail! obscure_quantity.to(u.m) # addition works for like units (1 * u.m) + (1 * u.cm) # and fails for the wrong dimensions (1 * u.m) + (1 * u.s) Explanation: Quantities as sanity checks End of explanation wavelengths = np.linspace(0.1, 1, 100) * u.micron # will fail without the correct equivalency passed in! frequencies = wavelengths.to(u.THz, equivalencies=u.spectral()) plt.plot(wavelengths, frequencies) plt.xlabel(r"$\lambda$ [$\mu$m]") plt.ylabel(r"$\nu$ [THz]") Explanation: Unit equivalencies Equivalencies allow you to do unit conversions under certain physical assumptions. For instance, it makes sense to talk about converting wavelength to frequency when you are discussing the properties of light waves in a vacuum. See http://docs.astropy.org/en/stable/units/equivalencies.html#unit-equivalencies. Spectral equivalence End of explanation intensity_unit = blackbody_nu(wavelengths[0], temperature=1e3 * u.K).unit wavelengths = np.logspace(-1, 1, 100) * u.micron temperatures = np.linspace(5e3, 1e4, 5) * u.K for T in temperatures: plt.plot(wavelengths, blackbody_nu(wavelengths, temperature=T), label='{:.2e}'.format(T)) plt.xscale('log') plt.legend(loc='best') plt.xlabel(r'$\lambda$ [$\mu$m]') plt.ylabel('$I_\\nu$ [{}]'.format(texify(intensity_unit))) intensity_unit = blackbody_lambda(wavelengths[0], temperature=1e3 * u.K).unit for T in temperatures: plt.plot(wavelengths, blackbody_lambda(wavelengths, temperature=T), label='{:.2e}'.format(T)) plt.xscale('log') plt.legend(loc='best') plt.xlabel(r'$\lambda$ [$\mu$m]') plt.ylabel('$I_\\lambda$ [{}]'.format(texify(intensity_unit))) T = 1e4 * u.K solid_angle = ((1 * u.arcsec) ** 2).to(u.sr) f_nu = blackbody_nu(wavelengths, temperature=T) * solid_angle f_lambda = blackbody_lambda(wavelengths, temperature=T) * solid_angle print(f_nu.unit) print(f_lambda.unit) # I_nu.to(I_lambda.unit) # would fail # for conversion of spectral energy density, we need to specify what part of the spectra we're looking at f_lambda_converted = f_nu.to(f_lambda.unit, equivalencies=u.spectral_density(wavelengths)) print(f_lambda_converted.unit) # shouldn't raise any exceptions! assert np.all(np.isclose(f_lambda.value, f_lambda_converted.value)) Explanation: Spectral energy density equivalencies End of explanation # e.g., from the example above np.isclose(f_lambda, f_lambda_converted) Explanation: Other cool equivalencies Doppler shifts (for both radio velocities and optical velocities), dimensionless angles, parallax. Words of warning Quantity arrays will often break functions that aren't prepared for them. Simple numpy operations still work, but for more complicated routines you'll have to convert to the units you want and then take the underlying array with the quantity.value attribute. End of explanation print((1 * u.m) / (2 * u.m), type((1 * u.m) / (2 * u.m))) Explanation: Even when you think you have a dimensionless array, it can still be a dimensionless quantity. End of explanation @u.quantity_input(angle=u.arcsec, distance=u.Mpc) def angle_to_size(angle, distance): return angle.to(u.radian).value * distance # this should work angle_to_size(1 * u.arcsec, 25 * u.Mpc).to(u.kpc) # quantity_input only checks for convertability, not that it's the same unit angle_to_size(1 * u.arcmin, 25 * u.Mpc).to(u.kpc) # this should raise an error angle_to_size(1 * u.m, 25 * u.Mpc) Explanation: Using units in your own code You can use the decorator quality_input as a clean way of ensuring your functions get the proper input. End of explanation coord = SkyCoord(45, 30, unit=u.deg) # ICRS is the reference frame coord # we can transform between coordinate frames coord.fk4 coord.fk5 coord.galactic # latitude and longitude are accessed with ra and dec (when in icrs or fk frames) coord.ra coord.dec Explanation: SkyCoord The SkyCoord class, from astropy.coordinates, is a convenient way of dealing with astronomical coordinate systems. http://docs.astropy.org/en/stable/coordinates/index.html End of explanation print(coord.to_string()) print(coord.to_string('dms')) print(coord.to_string('hmsdms')) print(coord.to_string('hmsdms', sep=':')) print(coord.to_string('hmsdms', sep=' ')) Explanation: The attributes ra and dec are Angles. They are subclasses of Quantity, and so they behave similarly, but have more specific functionality. See http://docs.astropy.org/en/stable/coordinates/angles.html#working-with-angles for more details. You can get nice string representations of angles for all your inane legacy software requirements. End of explanation # need network connection center_coord = SkyCoord.from_name('M31') center_coord # some mock coordinates n = 500 ra_values = np.random.randn(n) + center_coord.ra.deg dec_values = np.random.randn(n) + center_coord.dec.deg coords = SkyCoord(ra_values, dec_values, unit=u.deg) plt.scatter(coords.ra.deg, coords.dec.deg, s=100, edgecolor='k', label='Parent sample') plt.xlim(plt.xlim()[::-1]) # ra increases right to left plt.xlabel("Right ascension [deg]") plt.ylabel("Declination [deg]") # mock measurements n_sample = 100 astrometric_noise = 1 * u.arcsec sample_indices = np.random.choice(np.arange(len(coords)), n_sample) sample_ra = coords[sample_indices].ra.deg sample_dec = coords[sample_indices].dec.deg angles = 2 * np.pi * np.random.rand(n_sample) dr = astrometric_noise.to(u.deg).value * np.random.randn(n_sample) dx = np.cos(angles) * dr - np.sin(angles) * dr dy = np.sin(angles) * dr + np.cos(angles) * dr sample_coords = SkyCoord(sample_ra + dx, sample_dec + dy, unit=u.deg) plt.scatter(coords.ra.deg, coords.dec.deg, s=100, edgecolor='k', marker='o', alpha=0.8, label='Parent sample') plt.scatter(sample_coords.ra.deg, sample_coords.dec.deg, s=100, edgecolor='k', marker='v', alpha=0.8, label='Child sample') plt.xlim(plt.xlim()[::-1]) # ra increases right to left plt.xlabel("Right ascension [deg]") plt.ylabel("Declination [deg]") plt.legend(bbox_to_anchor=(1, 1)) # match_to_catalog_sky will return indices into coords of the closest matching objects, # the angular separation, and the physical distance (ignored here) idx, sep, dist = sample_coords.match_to_catalog_sky(coords) ideal_sep = astrometric_noise.to(u.deg) * np.random.randn(int(1e6)) plt.hist(np.abs(ideal_sep.to(u.arcsec)), histtype='step', lw=4, bins='auto', normed=True, label='Ideal') plt.hist(sep.arcsec, histtype='step', lw=4, bins='auto', normed=True, label='Data') plt.xlim(0, 3) plt.xlabel("Separation [arcsec]") plt.legend(loc='best') plt.scatter(coords[idx].ra.deg, coords[idx].dec.deg, s=100, edgecolor='k', marker='o', alpha=0.8, label='Matched parent sample') plt.scatter(sample_coords.ra.deg, sample_coords.dec.deg, s=100, edgecolor='k', marker='v', alpha=0.8, label='Child sample') plt.xlim(plt.xlim()[::-1]) # ra increases right to left plt.xlabel("Right ascension [deg]") plt.ylabel("Declination [deg]") plt.legend(bbox_to_anchor=(1, 1)) Explanation: Matching coordinates There are lots of specific use cases outlined here, but let's go over a simple catalog matching exercise. End of explanation
12,418	Given the following text description, write Python code to implement the functionality described below step by step Description: ES-DOC CMIP6 Model Properties - Landice MIP Era Step1: Document Authors Set document authors Step2: Document Contributors Specify document contributors Step3: Document Publication Specify document publication status Step4: Document Table of Contents 1. Key Properties 2. Key Properties --> Software Properties 3. Grid 4. Glaciers 5. Ice 6. Ice --> Mass Balance 7. Ice --> Mass Balance --> Basal 8. Ice --> Mass Balance --> Frontal 9. Ice --> Dynamics 1. Key Properties Land ice key properties 1.1. Overview Is Required Step5: 1.2. Model Name Is Required Step6: 1.3. Ice Albedo Is Required Step7: 1.4. Atmospheric Coupling Variables Is Required Step8: 1.5. Oceanic Coupling Variables Is Required Step9: 1.6. Prognostic Variables Is Required Step10: 2. Key Properties --> Software Properties Software properties of land ice code 2.1. Repository Is Required Step11: 2.2. Code Version Is Required Step12: 2.3. Code Languages Is Required Step13: 3. Grid Land ice grid 3.1. Overview Is Required Step14: 3.2. Adaptive Grid Is Required Step15: 3.3. Base Resolution Is Required Step16: 3.4. Resolution Limit Is Required Step17: 3.5. Projection Is Required Step18: 4. Glaciers Land ice glaciers 4.1. Overview Is Required Step19: 4.2. Description Is Required Step20: 4.3. Dynamic Areal Extent Is Required Step21: 5. Ice Ice sheet and ice shelf 5.1. Overview Is Required Step22: 5.2. Grounding Line Method Is Required Step23: 5.3. Ice Sheet Is Required Step24: 5.4. Ice Shelf Is Required Step25: 6. Ice --> Mass Balance Description of the surface mass balance treatment 6.1. Surface Mass Balance Is Required Step26: 7. Ice --> Mass Balance --> Basal Description of basal melting 7.1. Bedrock Is Required Step27: 7.2. Ocean Is Required Step28: 8. Ice --> Mass Balance --> Frontal Description of claving/melting from the ice shelf front 8.1. Calving Is Required Step29: 8.2. Melting Is Required Step30: 9. Ice --> Dynamics ** 9.1. Description Is Required Step31: 9.2. Approximation Is Required Step32: 9.3. Adaptive Timestep Is Required Step33: 9.4. Timestep Is Required	Python Code: # DO NOT EDIT ! from pyesdoc.ipython.model_topic import NotebookOutput # DO NOT EDIT ! DOC = NotebookOutput('cmip6', 'fio-ronm', 'sandbox-1', 'landice') Explanation: ES-DOC CMIP6 Model Properties - Landice MIP Era: CMIP6 Institute: FIO-RONM Source ID: SANDBOX-1 Topic: Landice Sub-Topics: Glaciers, Ice. Properties: 30 (21 required) Model descriptions: Model description details Initialized From: -- Notebook Help: Goto notebook help page Notebook Initialised: 2018-02-15 16:54:01 Document Setup IMPORTANT: to be executed each time you run the notebook End of explanation # Set as follows: DOC.set_author("name", "email") # TODO - please enter value(s) Explanation: Document Authors Set document authors End of explanation # Set as follows: DOC.set_contributor("name", "email") # TODO - please enter value(s) Explanation: Document Contributors Specify document contributors End of explanation # Set publication status: # 0=do not publish, 1=publish. DOC.set_publication_status(0) Explanation: Document Publication Specify document publication status End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: Document Table of Contents 1. Key Properties 2. Key Properties --> Software Properties 3. Grid 4. Glaciers 5. Ice 6. Ice --> Mass Balance 7. Ice --> Mass Balance --> Basal 8. Ice --> Mass Balance --> Frontal 9. Ice --> Dynamics 1. Key Properties Land ice key properties 1.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview of land surface model. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.model_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 1.2. Model Name Is Required: TRUE    Type: STRING    Cardinality: 1.1 Name of land surface model code End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.ice_albedo') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "prescribed" # "function of ice age" # "function of ice density" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 1.3. Ice Albedo Is Required: TRUE    Type: ENUM    Cardinality: 1.N Specify how ice albedo is modelled End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.atmospheric_coupling_variables') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 1.4. Atmospheric Coupling Variables Is Required: TRUE    Type: STRING    Cardinality: 1.1 Which variables are passed between the atmosphere and ice (e.g. orography, ice mass) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.oceanic_coupling_variables') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 1.5. Oceanic Coupling Variables Is Required: TRUE    Type: STRING    Cardinality: 1.1 Which variables are passed between the ocean and ice End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.prognostic_variables') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "ice velocity" # "ice thickness" # "ice temperature" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 1.6. Prognostic Variables Is Required: TRUE    Type: ENUM    Cardinality: 1.N Which variables are prognostically calculated in the ice model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.software_properties.repository') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2. Key Properties --> Software Properties Software properties of land ice code 2.1. Repository Is Required: FALSE    Type: STRING    Cardinality: 0.1 Location of code for this component. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.software_properties.code_version') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2.2. Code Version Is Required: FALSE    Type: STRING    Cardinality: 0.1 Code version identifier. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.key_properties.software_properties.code_languages') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2.3. Code Languages Is Required: FALSE    Type: STRING    Cardinality: 0.N Code language(s). End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.grid.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 3. Grid Land ice grid 3.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview of the grid in the land ice scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.grid.adaptive_grid') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 3.2. Adaptive Grid Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Is an adative grid being used? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.grid.base_resolution') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 3.3. Base Resolution Is Required: TRUE    Type: FLOAT    Cardinality: 1.1 The base resolution (in metres), before any adaption End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.grid.resolution_limit') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 3.4. Resolution Limit Is Required: FALSE    Type: FLOAT    Cardinality: 0.1 If an adaptive grid is being used, what is the limit of the resolution (in metres) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.grid.projection') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 3.5. Projection Is Required: TRUE    Type: STRING    Cardinality: 1.1 The projection of the land ice grid (e.g. albers_equal_area) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.glaciers.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 4. Glaciers Land ice glaciers 4.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview of glaciers in the land ice scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.glaciers.description') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 4.2. Description Is Required: TRUE    Type: STRING    Cardinality: 1.1 Describe the treatment of glaciers, if any End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.glaciers.dynamic_areal_extent') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 4.3. Dynamic Areal Extent Is Required: FALSE    Type: BOOLEAN    Cardinality: 0.1 Does the model include a dynamic glacial extent? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 5. Ice Ice sheet and ice shelf 5.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview of the ice sheet and ice shelf in the land ice scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.grounding_line_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "grounding line prescribed" # "flux prescribed (Schoof)" # "fixed grid size" # "moving grid" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 5.2. Grounding Line Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Specify the technique used for modelling the grounding line in the ice sheet-ice shelf coupling End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.ice_sheet') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 5.3. Ice Sheet Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Are ice sheets simulated? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.ice_shelf') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 5.4. Ice Shelf Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Are ice shelves simulated? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.mass_balance.surface_mass_balance') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 6. Ice --> Mass Balance Description of the surface mass balance treatment 6.1. Surface Mass Balance Is Required: TRUE    Type: STRING    Cardinality: 1.1 Describe how and where the surface mass balance (SMB) is calulated. Include the temporal coupling frequeny from the atmosphere, whether or not a seperate SMB model is used, and if so details of this model, such as its resolution End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.mass_balance.basal.bedrock') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 7. Ice --> Mass Balance --> Basal Description of basal melting 7.1. Bedrock Is Required: FALSE    Type: STRING    Cardinality: 0.1 Describe the implementation of basal melting over bedrock End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.mass_balance.basal.ocean') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 7.2. Ocean Is Required: FALSE    Type: STRING    Cardinality: 0.1 Describe the implementation of basal melting over the ocean End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.mass_balance.frontal.calving') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 8. Ice --> Mass Balance --> Frontal Description of claving/melting from the ice shelf front 8.1. Calving Is Required: FALSE    Type: STRING    Cardinality: 0.1 Describe the implementation of calving from the front of the ice shelf End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.mass_balance.frontal.melting') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 8.2. Melting Is Required: FALSE    Type: STRING    Cardinality: 0.1 Describe the implementation of melting from the front of the ice shelf End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.dynamics.description') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 9. Ice --> Dynamics ** 9.1. Description Is Required: TRUE    Type: STRING    Cardinality: 1.1 General description if ice sheet and ice shelf dynamics End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.dynamics.approximation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "SIA" # "SAA" # "full stokes" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 9.2. Approximation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Approximation type used in modelling ice dynamics End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.dynamics.adaptive_timestep') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 9.3. Adaptive Timestep Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Is there an adaptive time scheme for the ice scheme? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.landice.ice.dynamics.timestep') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 9.4. Timestep Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Timestep (in seconds) of the ice scheme. If the timestep is adaptive, then state a representative timestep. End of explanation
12,419	Given the following text description, write Python code to implement the functionality described below step by step Description: <small><i>This notebook was put together by Jake Vanderplas. Source and license info is on GitHub.</i></small> Density Estimation Step1: Introducing Gaussian Mixture Models We previously saw an example of K-Means, which is a clustering algorithm which is most often fit using an expectation-maximization approach. Here we'll consider an extension to this which is suitable for both clustering and density estimation. For example, imagine we have some one-dimensional data in a particular distribution Step2: Gaussian mixture models will allow us to approximate this density Step3: Note that this density is fit using a mixture of Gaussians, which we can examine by looking at the means_, covars_, and weights_ attributes Step4: These individual Gaussian distributions are fit using an expectation-maximization method, much as in K means, except that rather than explicit cluster assignment, the posterior probability is used to compute the weighted mean and covariance. Somewhat surprisingly, this algorithm provably converges to the optimum (though the optimum is not necessarily global). How many Gaussians? Given a model, we can use one of several means to evaluate how well it fits the data. For example, there is the Aikaki Information Criterion (AIC) and the Bayesian Information Criterion (BIC) Step5: Let's take a look at these as a function of the number of gaussians Step6: It appears that for both the AIC and BIC, 4 components is preferred. Example Step7: Now let's evaluate the log-likelihood of each point under the model, and plot these as a function of y Step8: The algorithm misses a few of these points, which is to be expected (some of the "outliers" actually land in the middle of the distribution!) Here are the outliers that were missed Step9: And here are the non-outliers which were spuriously labeled outliers Step10: Finally, we should note that although all of the above is done in one dimension, GMM does generalize to multiple dimensions, as we'll see in the breakout session. Other Density Estimators The other main density estimator that you might find useful is Kernel Density Estimation, which is available via sklearn.neighbors.KernelDensity. In some ways, this can be thought of as a generalization of GMM where there is a gaussian placed at the location of every training point!	Python Code: %matplotlib inline import numpy as np import matplotlib.pyplot as plt from scipy import stats plt.style.use('seaborn') Explanation: <small><i>This notebook was put together by Jake Vanderplas. Source and license info is on GitHub.</i></small> Density Estimation: Gaussian Mixture Models Here we'll explore Gaussian Mixture Models, which is an unsupervised clustering & density estimation technique. We'll start with our standard set of initial imports End of explanation np.random.seed(2) x = np.concatenate([np.random.normal(0, 2, 2000), np.random.normal(5, 5, 2000), np.random.normal(3, 0.5, 600)]) plt.hist(x, 80, normed=True) plt.xlim(-10, 20); Explanation: Introducing Gaussian Mixture Models We previously saw an example of K-Means, which is a clustering algorithm which is most often fit using an expectation-maximization approach. Here we'll consider an extension to this which is suitable for both clustering and density estimation. For example, imagine we have some one-dimensional data in a particular distribution: End of explanation from sklearn.mixture import GaussianMixture as GMM X = x[:, np.newaxis] clf = GMM(4, max_iter=500, random_state=3).fit(X) xpdf = np.linspace(-10, 20, 1000) density = np.array([np.exp(clf.score([[xp]])) for xp in xpdf]) plt.hist(x, 80, density=True, alpha=0.5) plt.plot(xpdf, density, '-r') plt.xlim(-10, 20); Explanation: Gaussian mixture models will allow us to approximate this density: End of explanation clf.means_ clf.covariances_ clf.weights_ plt.hist(x, 80, normed=True, alpha=0.3) plt.plot(xpdf, density, '-r') for i in range(clf.n_components): pdf = clf.weights_[i] * stats.norm(clf.means_[i, 0], np.sqrt(clf.covariances_[i, 0])).pdf(xpdf) plt.fill(xpdf, pdf, facecolor='gray', edgecolor='none', alpha=0.3) plt.xlim(-10, 20); Explanation: Note that this density is fit using a mixture of Gaussians, which we can examine by looking at the means_, covars_, and weights_ attributes: End of explanation print(clf.bic(X)) print(clf.aic(X)) Explanation: These individual Gaussian distributions are fit using an expectation-maximization method, much as in K means, except that rather than explicit cluster assignment, the posterior probability is used to compute the weighted mean and covariance. Somewhat surprisingly, this algorithm provably converges to the optimum (though the optimum is not necessarily global). How many Gaussians? Given a model, we can use one of several means to evaluate how well it fits the data. For example, there is the Aikaki Information Criterion (AIC) and the Bayesian Information Criterion (BIC) End of explanation n_estimators = np.arange(1, 10) clfs = [GMM(n, max_iter=1000).fit(X) for n in n_estimators] bics = [clf.bic(X) for clf in clfs] aics = [clf.aic(X) for clf in clfs] plt.plot(n_estimators, bics, label='BIC') plt.plot(n_estimators, aics, label='AIC') plt.legend(); Explanation: Let's take a look at these as a function of the number of gaussians: End of explanation np.random.seed(0) # Add 20 outliers true_outliers = np.sort(np.random.randint(0, len(x), 20)) y = x.copy() y[true_outliers] += 50 * np.random.randn(20) clf = GMM(4, max_iter=500, random_state=0).fit(y[:, np.newaxis]) xpdf = np.linspace(-10, 20, 1000) density_noise = np.array([np.exp(clf.score([[xp]])) for xp in xpdf]) plt.hist(y, 80, density=True, alpha=0.5) plt.plot(xpdf, density_noise, '-r') plt.xlim(-15, 30); Explanation: It appears that for both the AIC and BIC, 4 components is preferred. Example: GMM For Outlier Detection GMM is what's known as a Generative Model: it's a probabilistic model from which a dataset can be generated. One thing that generative models can be useful for is outlier detection: we can simply evaluate the likelihood of each point under the generative model; the points with a suitably low likelihood (where "suitable" is up to your own bias/variance preference) can be labeld outliers. Let's take a look at this by defining a new dataset with some outliers: End of explanation log_likelihood = np.array([clf.score_samples([[yy]]) for yy in y]) # log_likelihood = clf.score_samples(y[:, np.newaxis])[0] plt.plot(y, log_likelihood, '.k'); detected_outliers = np.where(log_likelihood < -9)[0] print("true outliers:") print(true_outliers) print("\ndetected outliers:") print(detected_outliers) Explanation: Now let's evaluate the log-likelihood of each point under the model, and plot these as a function of y: End of explanation set(true_outliers) - set(detected_outliers) Explanation: The algorithm misses a few of these points, which is to be expected (some of the "outliers" actually land in the middle of the distribution!) Here are the outliers that were missed: End of explanation set(detected_outliers) - set(true_outliers) Explanation: And here are the non-outliers which were spuriously labeled outliers: End of explanation from sklearn.neighbors import KernelDensity kde = KernelDensity(0.15).fit(x[:, None]) density_kde = np.exp(kde.score_samples(xpdf[:, None])) plt.hist(x, 80, density=True, alpha=0.5) plt.plot(xpdf, density, '-b', label='GMM') plt.plot(xpdf, density_kde, '-r', label='KDE') plt.xlim(-10, 20) plt.legend(); Explanation: Finally, we should note that although all of the above is done in one dimension, GMM does generalize to multiple dimensions, as we'll see in the breakout session. Other Density Estimators The other main density estimator that you might find useful is Kernel Density Estimation, which is available via sklearn.neighbors.KernelDensity. In some ways, this can be thought of as a generalization of GMM where there is a gaussian placed at the location of every training point! End of explanation
12,420	Given the following text description, write Python code to implement the functionality described below step by step Description: Model Complexity, Overfitting and Underfitting Step1: Validation Curves Step2: Exercise Plot the validation curve on the digit dataset for	Python Code: from plots import plot_kneighbors_regularization plot_kneighbors_regularization() Explanation: Model Complexity, Overfitting and Underfitting End of explanation from sklearn.datasets import load_digits from sklearn.ensemble import RandomForestClassifier from sklearn.learning_curve import validation_curve digits = load_digits() X, y = digits.data, digits.target model = RandomForestClassifier(n_estimators=20) param_range = range(1, 13) training_scores, validation_scores = validation_curve(model, X, y, param_name="max_depth", param_range=param_range, cv=5) training_scores.shape training_scores def plot_validation_curve(parameter_values, train_scores, validation_scores): train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) validation_scores_mean = np.mean(validation_scores, axis=1) validation_scores_std = np.std(validation_scores, axis=1) plt.fill_between(parameter_values, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.1, color="r") plt.fill_between(parameter_values, validation_scores_mean - validation_scores_std, validation_scores_mean + validation_scores_std, alpha=0.1, color="g") plt.plot(parameter_values, train_scores_mean, 'o-', color="r", label="Training score") plt.plot(parameter_values, validation_scores_mean, 'o-', color="g", label="Cross-validation score") plt.ylim(validation_scores_mean.min() - .1, train_scores_mean.max() + .1) plt.legend(loc="best") plt.figure() plot_validation_curve(param_range, training_scores, validation_scores) Explanation: Validation Curves End of explanation # %load solutions/validation_curve.py Explanation: Exercise Plot the validation curve on the digit dataset for: * a LinearSVC with a logarithmic range of regularization parameters C. * KNeighborsClassifier with a linear range of neighbors n_neighbors. What do you expect them to look like? How do they actually look like? End of explanation
12,421	Given the following text description, write Python code to implement the functionality described below step by step Description: A class to represent Phase Noise imports Step1: Introduction This document present a class in the plldesinger python module used to represent phase noise. The class have methods to compute the basic operation over phase noise, and they are Step2: Noise integration In order to find the integral of the noise of phase noise when few points are available it is necesary to be carefull and not introduce and error due to the logaritmic caracteristic of the the curve. Simple numerical integration of the curve in the figure gives a large error, specially if few points are available. There are two ways to avoid this problem one is to calculate the area under the curve between two points considering the log behavior of the curve [1], the other way to deal with the asymptocally behavior of the noise is to do the integration under the assumption of a linear behavior after log-log conversion. The following examples introduce the two methods and compare them with the result of the symbolic integration performed with Sympy [2]. Using Gardner equation By default the phase noise class integrate the noise using the equation find in the book of Gardner [1]. This can be done by using the integrate method as Step3: Noise integration with the trapz method Some times when used with noisy power spectrum densities, as the ones that result from transient simulations, the gardner method producing large truncation erros. In this case is better to interpolate points assuming the logaritmic tendency of the curve and then do a simple integration. This is implemented as and option in the integrate method and is ilustrated in the following Step4: Integration using Sympy The same calculation symbolically using Sympy that is ilustrated in the next code Step5: integrating over similar limits that before Step6: This is exactly what we found numerically in previous examples Generating samples of the phase noise It is also posible to generate samples of the noise for that we generate AWNG noise in the frequency domain we weight it with the power spectrum density and we calcualte the inverse FFT to have samples back in a similar fashion tha the algorithm described in [3] This notebook shows how to generate phase noise with certain power spectral density. The signal $ \phi[n]$ is generated by first creating AWNG noise for every of the frequency points where the spectrum is sampled. The signal constructed like that is just transform to a time sequence by means of the inverse FFT. Create noise with points and the slope Step7: Generate AWGN noise and calculate the phase in the time domain Step8: notice that at low frequency offsets is it is difficult to have the noise right, the reason being that the number of samples is small. Create noise samples using the pnoise class This algoritm it is implemented as a method in the pnoise class and can be used, conveniently, as described in the following code.	Python Code: from __future__ import division # Matrix computation import numpy as np from numpy import sqrt, diff, conj from numpy.random import randn # Signal processing routines import scipy.signal as sig # Symbolic math import sympy as sym sym.init_printing(use_latex='mathjax') # Plotting import matplotlib import matplotlib.pyplot as plt %matplotlib inline matplotlib.rcParams['font.size'] = 12 matplotlib.rcParams['figure.figsize'] = (9,6) matplotlib.rcParams['axes.labelsize'] = 'large' matplotlib.rcParams['axes.grid'] = True # Pll designer class to manipulate phase noise data import plldesigner.pnoise as pn Explanation: A class to represent Phase Noise imports End of explanation fm = np.logspace(4,8,100) lorentzian = pn.Pnoise(fm,10np.log10(1/(fmfm)),label='Lorentzian') fig = lorentzian.plot() white = pn.Pnoise(fm,-120np.ones(fm.shape),label='white') fig = white.plot() added = lorentzian+white added.label = 'addition' # Ploting in semilogx added.plot() leg = plt.legend() ix, = np.where(fm>1e6) added.ldbc[ix[0]] Explanation: Introduction This document present a class in the plldesinger python module used to represent phase noise. The class have methods to compute the basic operation over phase noise, and they are: Integration * Interpolation * Addition assuming statistically independence * Multiplication by a transfer function * Ploting * Model fit The phase noise is represented by its Doubled-Sided Band(SSB) spectrum: $$ \mathcal{L}(f_m) = 10 \log{\frac{\phi(f_m)^{2}}{2}} (dBc/Hz), $$ where $\phi(f_m)^2$ is the Singled-Sided band (SSB) power sepectral density (rad/Hz). Noise addition The addition is done assuming both signal are statistically independent. The following code shows a example of definition of noise with two vectors and the resulting power spectral density. End of explanation x = added.integrate() x Explanation: Noise integration In order to find the integral of the noise of phase noise when few points are available it is necesary to be carefull and not introduce and error due to the logaritmic caracteristic of the the curve. Simple numerical integration of the curve in the figure gives a large error, specially if few points are available. There are two ways to avoid this problem one is to calculate the area under the curve between two points considering the log behavior of the curve [1], the other way to deal with the asymptocally behavior of the noise is to do the integration under the assumption of a linear behavior after log-log conversion. The following examples introduce the two methods and compare them with the result of the symbolic integration performed with Sympy [2]. Using Gardner equation By default the phase noise class integrate the noise using the equation find in the book of Gardner [1]. This can be done by using the integrate method as: End of explanation added.integrate(method='trapz') Explanation: Noise integration with the trapz method Some times when used with noisy power spectrum densities, as the ones that result from transient simulations, the gardner method producing large truncation erros. In this case is better to interpolate points assuming the logaritmic tendency of the curve and then do a simple integration. This is implemented as and option in the integrate method and is ilustrated in the following End of explanation fm,LdBc,fl,fh = sym.symbols('fm,LdBc,fl,fh', postive=True) phi2_white = 210(-120/10) phi2_lorentzian = 2/(fmfm) phi2_added = phi2_white+phi2_lorentzian fig = plt.figure() ax = sym.plot(10sym.log(phi2_added/2,10),(fm,1e4,1e8), xscale = 'log') x = 10sym.log(phi2_added.subs({fm:1e6})/2,10) x.evalf() phi2_int = sym.integrate(phi2_added,fm) phi2_int Explanation: Integration using Sympy The same calculation symbolically using Sympy that is ilustrated in the next code End of explanation sym.sqrt(phi2_int.subs({fm:1e8})-phi2_int.subs({fm:1e4})) Explanation: integrating over similar limits that before End of explanation # Create a noise represenation with the noise points and slopes pnobj = pn.Pnoise.with_points_slopes([1e5, 1e6, 1e9],[-80,-100,-120],[-30,-20,0]) pnobj.plot('s') pnobj_ext = pnobj # Interpolate the noise in the logaritmic scale npoints = 2*16 fs = 500e6 fm = np.linspace( fs/npoints, fs/2, npoints) dfm = fm[1]-fm[0] pnobj_ext.fm=fm pnobj.plot('-', marker='x') Explanation: This is exactly what we found numerically in previous examples Generating samples of the phase noise It is also posible to generate samples of the noise for that we generate AWNG noise in the frequency domain we weight it with the power spectrum density and we calcualte the inverse FFT to have samples back in a similar fashion tha the algorithm described in [3] This notebook shows how to generate phase noise with certain power spectral density. The signal $ \phi[n]$ is generated by first creating AWNG noise for every of the frequency points where the spectrum is sampled. The signal constructed like that is just transform to a time sequence by means of the inverse FFT. Create noise with points and the slope End of explanation # create phase noise samples def gen_phase_noise_samples(fm, ldbc_fm, npoints): awgn_P1 = ( sqrt(0.5)(randn(npoints) +1jrandn(npoints)) ) P = 210*(ldbc_fm/10) dfm = fm[1]-fm[0] X = 2 (npoints-1) * sqrt( dfm * P ) * awgn_P1 X = np.r_[0,X, X.conj()[::-1]] phi = np.fft.ifft(X) return phi phi = gen_phase_noise_samples(fm, pnobj.ldbc, npoints) f, pxx = sig.welch(phi,fs, window='blackman', nperseg=2*12) pnobj.fm = f[1:] plt.semilogx(f[1:],10np.log10(pxx[1:]/2)) ax = pnobj.plot('-') Explanation: Generate AWGN noise and calculate the phase in the time domain End of explanation ## create a phase noise model with the points and slops pnobj = pn.Pnoise.with_points_slopes([1e5, 1e6, 1e9],[-80,-100,-120],[-30,-20,0]) fs = 500e6 npoints = 216 phi = pnobj.generate_samples(npoints, fs) ##Calculate the power spectral density f, pxx = sig.welch(phi,fs, window='blackman', nperseg=212) pnobj.fm = f[1:] plt.semilogx(f[1:],10*np.log10(pxx[1:]/2), label = 'Sampled noise') pnobj.plot('-', label='Asymptotic Model') leg = plt.legend() Explanation: notice that at low frequency offsets is it is difficult to have the noise right, the reason being that the number of samples is small. Create noise samples using the pnoise class This algoritm it is implemented as a method in the pnoise class and can be used, conveniently, as described in the following code. End of explanation
12,422	Given the following text description, write Python code to implement the functionality described below step by step Description: Rabi model fitting Step1: The model According to the Rabi model, the probability of being in the excited state, $p_e$ is given by, \begin{equation} P_e = a_0 + a_1 \frac{\Omega^2}{W^2} \left[ 1 - \left( e^{-\frac{t}{T_1}} \cos \left( 2\pi Wt + \phi \right) \right) \right] + a_2 \left( 1 - e^{-\frac{t}{T_{decay}}} \right) \end{equation} where $W = \sqrt{\Omega^2 + \delta^2}$, $\Omega$ is the Rabi frequency, $\delta$ is the detuning, $T_1$ is the relaxational coherence time, and $t$ is time. This gives a form which looks like the plot below. Step2: Plot example model Step3: Plot data and initial guess Step4: Curve fitting	Python Code: import numpy as np import matplotlib.pyplot as plt import scipy.stats as stats from scipy.optimize import curve_fit %matplotlib inline Explanation: Rabi model fitting End of explanation def rabiModel(time, rabiFreq, T1, Tdec, phi, a0, a1, a2, detuning=0.0): phi_deg = phi(np.pi/180) W = np.sqrt(rabiFreq2 + detuning2) ampl = rabiFreq2 / W2 osci = np.cos(2np.piWtime + phi_deg) expo = np.exp(-time/T1) decay = np.exp(-time/Tdec) return a0 + a1ampl(1 - (expo * osci)) + a2 * (1 - decay) Explanation: The model According to the Rabi model, the probability of being in the excited state, $p_e$ is given by, \begin{equation} P_e = a_0 + a_1 \frac{\Omega^2}{W^2} \left[ 1 - \left( e^{-\frac{t}{T_1}} \cos \left( 2\pi Wt + \phi \right) \right) \right] + a_2 \left( 1 - e^{-\frac{t}{T_{decay}}} \right) \end{equation} where $W = \sqrt{\Omega^2 + \delta^2}$, $\Omega$ is the Rabi frequency, $\delta$ is the detuning, $T_1$ is the relaxational coherence time, and $t$ is time. This gives a form which looks like the plot below. End of explanation time_start = 0.0 time_end = 7.0 time_steps = 1000 time_fit = np.linspace(time_start,time_end,time_steps) rabiFreq = 3 T1 = 2 Tdec = 20 phi = -65 a0 = 0 a1 = 0.5 a2 = -1.0 p_e_fit = rabiModel(time_fit, rabiFreq, T1, Tdec, phi, a0, a1, a2, detuning=0) plt.plot(time_fit, p_e_fit, 'g-', label='$P_e (\Delta = 0)$') plt.plot(time_fit, np.exp(-time_fit/T1), 'r--', label='$e^{-t/T_1}$') plt.xlabel("Time, ($\mu s$)") plt.ylabel("Prob. excited state, $P_e$") plt.title("Rabi model") plt.legend() plt.ylim([0.0, 1.0]) plt.grid() Explanation: Plot example model End of explanation d0,d1,d2,d3,d4,d5,d6,d7,d8,d9 = np.loadtxt('SR080317_026.dat',delimiter="\t",unpack=True) time_exp = d11e6 p_e_exp = d4-min(d4) p_e_exp = p_e_exp/max(p_e_exp) cropNum = 170 time_exp = time_exp[1:len(time_exp)-cropNum] p_e_exp = p_e_exp[1:len(p_e_exp)-cropNum] time_start = 0.0 time_end = 6.0 time_steps = 1000 time_fit = np.linspace(time_start,time_end,time_steps) # Initial guess rabiFreq = 3 T1 = 2 Tdec = 20 phi = -65 a0 = 0 a1 = 0.5 a2 = -1.0 p_e_fit = rabiModel(time_fit, rabiFreq, T1, Tdec, phi, a0, a1, a2, detuning=0) plt.plot(time_fit, p_e_fit, 'g-', label='$P_e (\Delta = 0)$') plt.plot(time_exp,p_e_exp, 'b-', label='data') plt.xlabel("Time, ($\mu s$)") plt.ylabel("Prob. excited state, $P_e$") plt.title("Initial guess") plt.legend() plt.ylim([0.0, 1.0]) plt.grid() Explanation: Plot data and initial guess End of explanation guess = [rabiFreq, T1, Tdec, phi, a0, a1, a2] popt,pcov = curve_fit(rabiModel, time_exp, p_e_exp, p0=guess) perr = np.sqrt(np.diag(pcov)) params = ['rabiFreq', 'T1', 'Tdec', 'phi', 'a0', 'a1', 'a2'] for idx in range(len(params)): print( "The fitted value of ", params[idx], " is ", popt[idx], " with error ", perr[idx] ) p_e_fit = rabiModel(time_fit,popt) plt.plot(time_fit, p_e_fit, 'g-', label='$P_e (\Delta = 0)$') plt.plot(time_exp,p_e_exp, 'b-', label='data') plt.xlabel("Time, ($\mu s$)") plt.ylabel("Prob. excited state, $P_e$") plt.title("Rabi model fit") plt.legend() plt.ylim([0.0, 1.0]) plt.grid() Explanation: Curve fitting End of explanation
12,423	Given the following text description, write Python code to implement the functionality described below step by step Description: Encontro 03 Step1: Carregando e visualizando o grafo	Python Code: import sys sys.path.append('..') import socnet as sn Explanation: Encontro 03: Grafos Reais Importando a biblioteca: End of explanation sn.node_size = 3 sn.node_color = (0, 0, 0) sn.edge_width = 1 sn.edge_color = (192, 192, 192) sn.node_label_position = 'top center' g = sn.load_graph('twitter.gml') sn.show_graph(g, nlab=True) Explanation: Carregando e visualizando o grafo: End of explanation
12,424	Given the following text description, write Python code to implement the functionality described below step by step Description: Network Analysis This group exercise is designed to develop an understanding of basic network measures and to start participants thinking about interesting research questions that can be enabled by network science. <ol> <li>Divide yourselves into groups of four by counting off in order around the room.</li> <li>For 10 minutes, explore the <a href="https Step1: Introduction to networkx For very small networks, it can be helpful to visualize the nodes and edges. Below we have colored the nodes with respect to their group within the karate club. Step2: A natural question you might like to ask about a network, is what are the most "important" nodes? There are many definitions of network importance or centrality. Here let's just consider one of the most straightforward measures Step3: NetworkX can be used to return a normalized (divided by the maximum possible degree of the network) degree centrality for all nodes in the network. Step4: From both measures, we can see that nodes 1 and 34 have the highest degree. (These happen to be the two leaders from the two groups within the club.) On large networks, you might want to look at the degree distribution of your network ... Step5: Another network feature that you might like to know about your network, is how assortative or modular is it. Another way of asking this, is how likely is it for similar nodes to be connected to each other? This similarity can be measured along any number of network attributes. Here we ask, how much more likely are nodes from the same group within the karate club connected to each, than we would expect at random? Step6: You can also add edge attributes, either all at once using set_edge_attributes (like we did above for set_node_attributes), or on an edge by edge basis as shown below. The shortest path between two nodes using that weight can then be calculated. Step7: Lastly, one might want to create a function on top of these networks. For example, to measure the average degree of a node's neighbors	Python Code: with open('karate_edges_77.txt', 'rb') as file: karate_club = nx.read_edgelist(file) # Read in the edges groups = {} with open('karate_groups.txt', 'r') as file: for line in file: [node, group] = re.split(r'\t+', line.strip()) groups[node] = int(group) nx.set_node_attributes(karate_club, name = 'group', values = groups) # Add attributes to the nodes (e.g. group membership) Explanation: Network Analysis This group exercise is designed to develop an understanding of basic network measures and to start participants thinking about interesting research questions that can be enabled by network science. <ol> <li>Divide yourselves into groups of four by counting off in order around the room.</li> <li>For 10 minutes, explore the <a href="https://icon.colorado.edu/#!/networks">Index of Complex Networks (ICON)</a> database and identify a network your group might like to investigate further. (If someone in your group has a network ready, that you'd all like to analyze feel free to work on this network instead.)</li> <li>Write code to import this network into Python. Play with the <a href="https://networkx.github.io/documentation/stable/reference/algorithms/index.html">built-in functionality</a> of `networkx`. (See the code below for help with this step.)</li> <li>For 15 minutes, identify a possible research question using this data. Evaluate the strengths and weaknesses of this data.</li> <li>Outline a research design that could be used to address the weaknesses of the data you collected (e.g. think about possible data sets you could combine with this network), or otherwise improve your ability to answer the research question.</li> </ol> There is only one requirement: the group member with the least amount of experience coding should be responsible for typing the code into a computer. After 40 minutes you should be prepared to give a 3 minute presentation of your work. Remember that these daily exercises are for you to get to know each other better, are not expected to be fully-fleshed out research project, and a way for you to explore research areas that may be new to you. Importing ICON data Visit the ICON website (<a href="https://icon.colorado.edu/#!/networks">link</a>). You can search the index using the checkboxes under the tabs "network domain," "subdomain," "graph properties," and "size". You can also type in keywords related to the network you would like to find. Here is a screenshot: <img src="https://user-images.githubusercontent.com/6633242/45270410-79e66a00-b45a-11e8-83df-852d919cdcec.png"></img> To download a network, click the small yellow downward arrow and follow the link listed under "source". Importing this data into Python using networkx will depend on the file type of the network you download. (Check out the <a href="https://networkx.github.io/documentation/stable/reference/readwrite/index.html">package's documentation</a> for how to import networks from different file types.) Here's what it looks like to import the Zachary Karate Club from the edglist provided: End of explanation position = nx.spring_layout(karate_club) nx.draw_networkx_labels(karate_club, pos = position) colors = [] # Color the nodes acording to their group for attr in nx.get_node_attributes(karate_club, 'group').values(): if attr == 1: colors.append('blue') else: colors.append('green') nx.draw(karate_club, position, node_color = colors) # Visualize the graph Explanation: Introduction to networkx For very small networks, it can be helpful to visualize the nodes and edges. Below we have colored the nodes with respect to their group within the karate club. End of explanation print([(n, karate_club.degree(n)) for n in karate_club.nodes()]) Explanation: A natural question you might like to ask about a network, is what are the most "important" nodes? There are many definitions of network importance or centrality. Here let's just consider one of the most straightforward measures: degree centrality -- the number of edges that start or end at a given node. End of explanation degrees = nx.degree_centrality(karate_club) print(degrees) Explanation: NetworkX can be used to return a normalized (divided by the maximum possible degree of the network) degree centrality for all nodes in the network. End of explanation # Enron email data set: http://snap.stanford.edu/data/email-Enron.html. # (You can search "Email network (Enron corpus)" in ICON.) with open('email_enron.txt', 'rb') as file: enron = nx.read_edgelist(file, comments='#') # Read in the edges print("Enron network contains {0} nodes, and {1} edges.".format(len(enron.nodes()), len(enron.edges()))) degree_sequence = list(dict(enron.degree()).values()) print("Average degree: {0}, Maximum degree: {1}".format(np.mean(degree_sequence), max(degree_sequence))) plt.hist(degree_sequence, bins=30) # Plots histogram of degree sequence plt.show() Explanation: From both measures, we can see that nodes 1 and 34 have the highest degree. (These happen to be the two leaders from the two groups within the club.) On large networks, you might want to look at the degree distribution of your network ... End of explanation assort = nx.attribute_assortativity_coefficient(karate_club, 'group') print("Assortativity coefficient: {0}".format(assort)) Explanation: Another network feature that you might like to know about your network, is how assortative or modular is it. Another way of asking this, is how likely is it for similar nodes to be connected to each other? This similarity can be measured along any number of network attributes. Here we ask, how much more likely are nodes from the same group within the karate club connected to each, than we would expect at random? End of explanation # Example borrowed from: https://www.cl.cam.ac.uk/teaching/1314/L109/tutorial.pdf g = nx.Graph() g.add_edge('a', 'b', weight=0.1) g.add_edge('b', 'c', weight=1.5) g.add_edge('a', 'c', weight=1.0) g.add_edge('c', 'd', weight=2.2) print(nx.shortest_path(g, 'b', 'd')) print(nx.shortest_path(g, 'b', 'd', weight='weight')) Explanation: You can also add edge attributes, either all at once using set_edge_attributes (like we did above for set_node_attributes), or on an edge by edge basis as shown below. The shortest path between two nodes using that weight can then be calculated. End of explanation # Example borrowed from: https://www.cl.cam.ac.uk/teaching/1314/L109/tutorial.pdf def avg_neigh_degree(g): data = {} for n in g.nodes(): if g.degree(n): data[n] = float(sum(g.degree(i) for i in g[n]))/g.degree(n) return data avg_neigh_degree(g) # Can you confirm that this is returning the correct results? Explanation: Lastly, one might want to create a function on top of these networks. For example, to measure the average degree of a node's neighbors: End of explanation
12,425	Given the following text description, write Python code to implement the functionality described below step by step Description: Compute iterative reweighted TF-MxNE with multiscale time-frequency dictionary The iterative reweighted TF-MxNE solver is a distributed inverse method based on the TF-MxNE solver, which promotes focal (sparse) sources Step1: Load somatosensory MEG data Step2: Run iterative reweighted multidict TF-MxNE solver Step3: Generate stc from dipoles Step4: Show the evoked response and the residual for gradiometers	Python Code: # Author: Mathurin Massias <[email protected]> # Yousra Bekhti <[email protected]> # Daniel Strohmeier <[email protected]> # Alexandre Gramfort <[email protected]> # # License: BSD-3-Clause import os.path as op import mne from mne.datasets import somato from mne.inverse_sparse import tf_mixed_norm, make_stc_from_dipoles from mne.viz import plot_sparse_source_estimates print(__doc__) Explanation: Compute iterative reweighted TF-MxNE with multiscale time-frequency dictionary The iterative reweighted TF-MxNE solver is a distributed inverse method based on the TF-MxNE solver, which promotes focal (sparse) sources :footcite:StrohmeierEtAl2015. The benefits of this approach are that: it is spatio-temporal without assuming stationarity (source properties can vary over time), activations are localized in space, time, and frequency in one step, the solver uses non-convex penalties in the TF domain, which results in a solution less biased towards zero than when simple TF-MxNE is used, using a multiscale dictionary allows to capture short transient activations along with slower brain waves :footcite:BekhtiEtAl2016. End of explanation data_path = somato.data_path() subject = '01' task = 'somato' raw_fname = op.join(data_path, 'sub-{}'.format(subject), 'meg', 'sub-{}_task-{}_meg.fif'.format(subject, task)) fwd_fname = op.join(data_path, 'derivatives', 'sub-{}'.format(subject), 'sub-{}_task-{}-fwd.fif'.format(subject, task)) # Read evoked raw = mne.io.read_raw_fif(raw_fname) raw.pick_types(meg=True, eog=True, stim=True) events = mne.find_events(raw, stim_channel='STI 014') reject = dict(grad=4000e-13, eog=350e-6) event_id, tmin, tmax = dict(unknown=1), -0.5, 0.5 epochs = mne.Epochs(raw, events, event_id, tmin, tmax, reject=reject, baseline=(None, 0)) evoked = epochs.average() evoked.crop(tmin=0.0, tmax=0.2) # Compute noise covariance matrix cov = mne.compute_covariance(epochs, rank='info', tmax=0.) del epochs, raw # Handling forward solution forward = mne.read_forward_solution(fwd_fname) Explanation: Load somatosensory MEG data End of explanation alpha, l1_ratio = 20, 0.05 loose, depth = 0.9, 1. # Use a multiscale time-frequency dictionary wsize, tstep = [4, 16], [2, 4] n_tfmxne_iter = 10 # Compute TF-MxNE inverse solution with dipole output dipoles, residual = tf_mixed_norm( evoked, forward, cov, alpha=alpha, l1_ratio=l1_ratio, n_tfmxne_iter=n_tfmxne_iter, loose=loose, depth=depth, tol=1e-3, wsize=wsize, tstep=tstep, return_as_dipoles=True, return_residual=True) Explanation: Run iterative reweighted multidict TF-MxNE solver End of explanation stc = make_stc_from_dipoles(dipoles, forward['src']) plot_sparse_source_estimates( forward['src'], stc, bgcolor=(1, 1, 1), opacity=0.1, fig_name=f"irTF-MxNE (cond {evoked.comment})") Explanation: Generate stc from dipoles End of explanation ylim = dict(grad=[-300, 300]) evoked.copy().pick_types(meg='grad').plot( titles=dict(grad='Evoked Response: Gradiometers'), ylim=ylim) residual.copy().pick_types(meg='grad').plot( titles=dict(grad='Residuals: Gradiometers'), ylim=ylim) Explanation: Show the evoked response and the residual for gradiometers End of explanation
12,426	Given the following text description, write Python code to implement the functionality described below step by step Description: Reproducing "Observations on the statistical iterations of matrices" by J.H. Hetherington* I. Introduction We can use stochastic iteration to effect the power method for sampling the extremal eigenvalues/eigenvectors of a matrix with sampling access to a matrix-vector product. In the context of many-body physics, this matrix might be a Hamiltonian and we might be interested in, e.g, an approximation of the affiliated Green's function as in diffusion Monte Carlo. Naive stochastic iteration can result in two effects that we would like to mitigate if we are to use it Step1: V. The Dilemma of the Symmetric Matrix Of course, none of this is particularly useful as it assumes that we know the spectrum and eigenvectors a priori. Next we move onto the central example of the paper in which we estimate the largest eigenvalue of a symmetric non-negative matrix (something that is starting to look like a Hamiltonian). VI. Using Non-Stochastic Matrices Assume for a moment that we have access to a factorized form of a symmetric, non-negative (but non-stochastic) matrix. We will demonstrate via stochastic iteration that we can estimate the largest eigenvalue of this matrix. Step2: To estimate the largest eigenvector of A, we will now generate a Markov Chain from the probabilities in the stochastic factor, and weight the configurations with the respective elements of the diagonal factor. We will then take the estimate of the eigenvector, and extract its associated eigenvalue. Step3: This is a decent estimate, but not perfect. Looks good, right? Step4: It turns out that the weights used in our Markov Chain explode, which means that we cannot carry this out indefinitely to reduce variance. Step5: Running this calculation for many different chain lengths, we see that increasing the chain length does not appear to generally make things better. Of course, this calculation is only for a single walker. VII. Difficulties Arise Hetherington quantifies the difficulties that we are observing by plotting the distribution of weights in Figure 2. Let us reproduce this plot Step6: An important thing to note in comparing this with the paper is that depending on the length of the Markov Chain (in this case 50) there are certain values of n that will never be reached. That is why every other entry (all of the even values of n) have proabability 0. For the interested reader, it might be fun to watch the separation between these two sets of peaks grow as the length of the Markov Chain increases. What is really important here? * The most probable answer is not the same as the average answer. * The variance associated with estimators from this Markov chain will grow with the length of the chain. * The formal variance is non-monotonic in the length of the chain but it quickly turns over to exponential growth. This means that there is an optimal sequence length, beyond which continued iteration will help less than reducing statistical error by increasing the number of walkers. Next we reproduce Figure 3. Here we demonstrate the the eigenvector estimate not only looks very different from the actual eigenvector, but that it does not resemble the eigenvector estimate predicted via matrix multiplication (i.e., deterministic power method). Step7: VIII. The Weighted Average Rather than using the eigenvector itself to compute the eigenvalue estimate, this section introduces a functional form for an estimator. We use it to reproduce Figure 4. Step8: Here we see the fundamental tradeoff that we have to deal with. Even for a Markov Chain with 20,000 iterations we have a choice between problems	Python Code: # construct an exemplary non-negative matrix A = zeros([2,2]) A[0,0] = 2.0 A[1,1] = 1.0 A[1,0] = 3.0 A[0,1] = 4.0 print 'Matrix A: \n', A # verify that columns do not sum to 1 print 'Column 0 sum: ', sum(A[:,0]) print 'Column 1 sum: ', sum(A[:,1]) print 'Matrix A is non-negative but the columns do not sum to 1' # compute the eigenvalues and left/right eigenvectors w, vl, vr = eig(A, left=True) # fill out the entries of the stochastic part of A in the silliest way possible # direct application of Equation 2 M = zeros([2,2]) scl = 1.0/abs(w[0]) M[0,0] = sclvl[0,0]A[0,0]/vl[0,0] M[0,1] = sclvl[0,0]A[0,1]/vl[1,0] M[1,0] = sclvl[1,0]A[1,0]/vl[0,0] M[1,1] = sclvl[1,0]A[1,1]/vl[1,0] print 'Stochastic factor of A (M): \n', M # compute the eigenvalues and left/right eigenvectors wStoc, vlStoc, vrStoc = eig(M, left=True) print 'Eigenvalues of M (largest is 1): ', wStoc print 'Left eigenvectors of M (eigenvector corresponding to 1 is ~ to all 1s): \n', vlStoc # compute the diagonal factor of A (below Equation 4) wDiag = eye(2) wDiag[0,0] = sum(A[:,0]) wDiag[1,1] = sum(A[:,1]) print 'Diagonal factor of A (w): \n', wDiag print 'Matrix A: \n', A print 'Product Mw: \n', dot(M,wDiag) Explanation: Reproducing "Observations on the statistical iterations of matrices" by J.H. Hetherington I. Introduction We can use stochastic iteration to effect the power method for sampling the extremal eigenvalues/eigenvectors of a matrix with sampling access to a matrix-vector product. In the context of many-body physics, this matrix might be a Hamiltonian and we might be interested in, e.g, an approximation of the affiliated Green's function as in diffusion Monte Carlo. Naive stochastic iteration can result in two effects that we would like to mitigate if we are to use it: Seemingly anomalous growth in variance as the number of iterations increases. Stable or reducing variance, but the introduction of bias. In this notebook, we will walk through the results in Hetherington's paper and reproduce them one by one. This culminates in a simple stochastic reconfiguration implementation for controlling variance and bias with a fixed population of walkers. Fun fact: Hetherington is one of a select few physicists to have co-authored a paper with a domestic cat (https://en.wikipedia.org/wiki/F.D.C._Willard) II and III. Stochastic Matrices and Markov Chains Most of us probably know what a stochastic matrix is. It is a matrix that is: Comprised of non-negative entries... * ...and columns that sum to 1 We might interpret the entries of such a matrix as probabilities. The rows and columns of our matrix comprise a discrete state space through which we might imagine a system evolving. The entry in the ith row and jth column is then to be interpreted as the probability of the system transitioning into basis state i, given that it is found in basis state j. What do we know about these matrices? * They have a left eigenvector proportional to all 1s, with eigenvalue 1. * 1 is the largest eigenvalue. * If the matrix cannot be put in block diagonal form via permutation, this maximum eigenvalue is non-degenerate. If we conceive of repeated application of this matrix as applying the power method to project out the largest eigenvector/eigenvalue of our matrix (which we assume to be non-degenerate), then the relationship between the properties of this type of matrix and the properties of a Markov Chain are evident. This largest eigenvector is, indeed, the stationary distribution of some Markov Chain. Thus, we see that there is a relationship between a Markov Chain generated by iterating some matrix and its extremal eigenvalues. IV. Non-negative Matrices What happens if rather than considering matrices that are both non-negative and have columns that sum to unity, we consider more general non-negative matrices. We can factorize these matrices into a product of a stochastic matrix and a diagonal matrix. In Equation 2* of Hetherington's paper, he demonstrates that a non-negative matrix can be "made stochastic" given access to its extremal left eigenpair. Below we demonstrate how to do this for a contrived 2x2 example: Note: Equation 2 has a typo, it should be $M_{ij} = \frac{1}{\lambda} Z_i A_{ij} Z_{j}^{-1}$ End of explanation # create the SYMMETRIC A matrix of interest in the paper A = zeros([2,2]) scl = 1.0/sqrt(6.04.0) A[0,0] = scl5 A[0,1] = scl1 A[1,0] = scl1 A[1,1] = scl3 w, vl, vr = eig(A, left=True) # we know that the eigenvalues are real, so just print them out as such print 'Eigenvalues of A: ', real(w) wExact = real(w[0]) # create the diagonal factor of A w = zeros([2,2]) w[0,0] = sum(A[:,0]) w[1,1] = sum(A[:,1]) print 'Diagonal factor of A: \n', w # create the stochastic factor of A M = zeros([2,2]) M[0,0] = A[0,0]/w[0,0] M[0,1] = A[0,1]/w[1,1] M[1,0] = A[1,0]/w[0,0] M[1,1] = A[1,1]/w[1,1] print 'Stochastic factor of A: \n', M Explanation: V. The Dilemma of the Symmetric Matrix Of course, none of this is particularly useful as it assumes that we know the spectrum and eigenvectors a priori. Next we move onto the central example of the paper in which we estimate the largest eigenvalue of a symmetric non-negative matrix (something that is starting to look like a Hamiltonian). VI. Using Non-Stochastic Matrices Assume for a moment that we have access to a factorized form of a symmetric, non-negative (but non-stochastic) matrix. We will demonstrate via stochastic iteration that we can estimate the largest eigenvalue of this matrix. End of explanation # the paper makes a point of using weights that are reciprocals, # such that the weight of a given configuration is (6/4)(n/2)... # given such a weight, this routine computes the integer n def getN(weight): return int(log(weight2)/log(6.0/4.0)) def estimateEig(nIterations, M, w): # starting from state 0 currentState = 0 weight = zeros(nIterations) weight[0] = 1.0 # start with a weight of 1 nvec = zeros(nIterations) # for keeping track of the weight (in terms of its integer power) at each iteration nvec[0] = 0 rvec = rand(nIterations-1) # for storing the running estimate of the largest eigenvector of A eigEst = zeros([2,nIterations]) eigEst[0,0] = M[0,currentState]weight[0] eigEst[1,0] = M[1,currentState]weight[0] for i in range(1,nIterations): # the probability of staying in the current state is given by a diagonal element of the stochastic factor # ...and because this is a 2-state example, this is enough to constrain the probability of switching into the other state probStay = M[currentState,currentState] # if random number is greater than probability of staying, # then for high probability of staying, probStay is close to 1 # and it is less likely that a number will be greater than probStay # so you should switch if this does happen if(rvec[i-1]>probStay): currentState = mod(currentState+1,2) weight[i] = w[currentState,currentState]weight[i-1] nvec[i] = getN(weight[i]) eigEst[0,i] = eigEst[0,i-1] + M[0,currentState]weight[i] eigEst[1,i] = eigEst[1,i-1] + M[1,currentState]weight[i] return weight, eigEst nIterations = 1000 weight, eigEst = estimateEig( nIterations, M, w ) # given the unnormalized eigenvector estimate, normalize it and compute the associated eigenvalue # looks kind of like the local energy, yes? nrmEst = sqrt(dot(eigEst[:,nIterations-1],eigEst[:,nIterations-1])) eigNrm = eigEst[:,nIterations-1]/nrmEst print 'Estimate of largest eigenvalue of A: ', dot(eigNrm,dot(A,eigNrm)) print 'Actual eigenvalue: ', wExact Explanation: To estimate the largest eigenvector of A, we will now generate a Markov Chain from the probabilities in the stochastic factor, and weight the configurations with the respective elements of the diagonal factor. We will then take the estimate of the eigenvector, and extract its associated eigenvalue. End of explanation # weight vs iteration for the 1000 iteration Markov Chain figure(figsize=[12,10]) plot(log10(weight)) xlabel('Markov Chain Iteration') ylabel('Log10 Weight') title('Demonstration that the weights explode with the number of iterations') Explanation: This is a decent estimate, but not perfect. Looks good, right? End of explanation # vary the length of the Markov chain iterationList = linspace(1,1000,1000) wEstList = zeros(len(iterationList)) for idx,nIterations in enumerate(iterationList): weight, eigEst = estimateEig( int(nIterations), M, w ) nrmEst = sqrt(dot(eigEst[:,nIterations-1],eigEst[:,nIterations-1])) eigNrm = eigEst[:,nIterations-1]/nrmEst wEstList[idx] = dot(eigNrm,dot(A,eigNrm)) # estimates vs length of Markov chain figure(figsize=[12,10]) plot(iterationList, wEstList, 'o', label='Estimated eigenvalue') axhline(wExact, color='black', label='Exact eigenvalue') xlabel('Length of Markov Chain') ylabel('Eigenvalue estimate') title('Stochastic iteration to compute eigenvalue estimate from estimated eigenvector') legend() Explanation: It turns out that the weights used in our Markov Chain explode, which means that we cannot carry this out indefinitely to reduce variance. End of explanation nWalkers = 500000 nIterations = 50 ensembleP = zeros([nIterations2+1,2]) def getN(weight): return int(round(log(weight*2)/log(6.0/4.0))) for walker in arange(nWalkers): # decide randomly on the initial state if(rand(1)<0.5): currentState = 0 increment = True else: currentState = 1 increment = False nvec = zeros(nIterations,dtype=int) nvec[0] = 0 rvec = rand(nIterations-1) for i in range(1,nIterations): probStay = M[currentState,currentState] if(increment): nvec[i] = nvec[i-1] + 1 else: nvec[i] = nvec[i-1] - 1 if(rvec[i-1]>probStay): currentState = mod(currentState+1,2) increment = not(increment) ensembleP[nIterations+1+nvec[-1],currentState] += 1.0 n = linspace(-nIterations,nIterations,2nIterations+1) figure(figsize=[12,10]) plot(n,ensembleP[:,0], 'o', label='i=1') plot(n,ensembleP[:,1], 'o', label='i=2') xlabel('n') ylabel('p(n,i)') title('Reproduction of Fig. 2a') legend() xlim([-30,50]) figure(figsize=[12,10]) plot(n,ensembleP[:,0](1.5)(n/2.), 'o', label='i=1') plot(n,ensembleP[:,1](1.5)(n/2.), 'o', label='i=2') xlabel('n') ylabel('wn p(n,i)') title('Reproduction of Fig. 2b') xlim([-30,50]) legend() Explanation: Running this calculation for many different chain lengths, we see that increasing the chain length does not appear to generally make things better. Of course, this calculation is only for a single walker. VII. Difficulties Arise Hetherington quantifies the difficulties that we are observing by plotting the distribution of weights in Figure 2. Let us reproduce this plot: End of explanation nWalkers = 512 nIterations = 500 ensembleX = zeros([nIterations,2]) ensembleX[0,0] = 1.0 ensembleX[0,1] = 0.0 def getN(weight): return int(round(log(weight2)/log(6.0/4.0))) for walker in arange(nWalkers): # do not decide randomly on the initial state, you know it is 0 currentState = 0 nvec = zeros(nIterations,dtype=int) nvec[0] = 0 rvec = rand(nIterations-1) weight = zeros(nIterations) weight[0] = 1.0 for i in range(1,nIterations): probStay = M[currentState,currentState] if(rvec[i-1]>probStay): currentState = mod(currentState+1,2) weight[i] = w[currentState,currentState]weight[i-1] ensembleX[i,:] += M[:,currentState]weight[i] analX = zeros([nIterations,2]) analX[0,0] = 1.0 analX[0,1] = 0.0 for i in range(1,nIterations): analX[i,:] = dot(A,analX[i-1,:]) figure(figsize=[12,10]) plot(arctan2(ensembleX[:,1],ensembleX[:,0]),'.', label='Stochastic Iteration') plot(arctan2(analX[:,1],analX[:,0]), '-', label='Matrix Multiplication') xlabel('N') ylabel('arctan($X_2/X_1$)') title('Exponential Growth in Error for Stochastic Eigenvector Estimate') legend() figure(figsize=[12,10]) xlim([0,50]) ylim([0,0.7]) plot(arctan2(ensembleX[:,1],ensembleX[:,0]),'.', label='Stochastic Iteration') plot(arctan2(analX[:,1],analX[:,0]), '-', label='Matrix Multiplication') xlabel('N') ylabel('arctan($X_2/X_1$)') title('Exponential Growth in Error for Stochastic Eigenvector Estimate') legend() Explanation: An important thing to note in comparing this with the paper is that depending on the length of the Markov Chain (in this case 50) there are certain values of n that will never be reached. That is why every other entry (all of the even values of n) have proabability 0. For the interested reader, it might be fun to watch the separation between these two sets of peaks grow as the length of the Markov Chain increases. What is really important here? * The most probable answer is not the same as the average answer. * The variance associated with estimators from this Markov chain will grow with the length of the chain. * The formal variance is non-monotonic in the length of the chain but it quickly turns over to exponential growth. This means that there is an optimal sequence length, beyond which continued iteration will help less than reducing statistical error by increasing the number of walkers. Next we reproduce Figure 3. Here we demonstrate the the eigenvector estimate not only looks very different from the actual eigenvector, but that it does not resemble the eigenvector estimate predicted via matrix multiplication (i.e., deterministic power method). End of explanation def weightedAverage( L, nTrials ): nIterations = 20000 M = zeros([2,2]) M[0,0] = 5./6. M[0,1] = 1./4. M[1,0] = 1./6. M[1,1] = 3./4. w = zeros([2,2]) w[0,0] = sqrt(6./4.) w[1,1] = sqrt(4./6.) lambdaEsts = zeros(nTrials) for trial in arange(nTrials): # do not decide randomly on the initial state, you know it is 0 currentState = 0 Gnvec = zeros(nIterations) wvec = zeros(nIterations) rvec = rand(nIterations) weightList = [] cweight = w[currentState,currentState] wvec[0] = cweight Gnvec[0] = 1.0 weightList.append( cweight ) for i in range(1,nIterations): probStay = M[currentState,currentState] if(rvec[i]>probStay): currentState = mod(currentState+1,2) cweight = w[currentState,currentState] wvec[i] = cweight if(L==0): Gnvec[i] = 1.0 else: Gnvec[i] = reduce( lambda x, y: xy, weightList ) weightList.append(cweight) if(len(weightList)>L): weightList.pop(0) lambdaEsts[trial] = dot(wvec,Gnvec)/sum(Gnvec) return mean(lambdaEsts), var(lambdaEsts) # this guy will take like 5 minutes to run Lvals = [0,1,2,3,4,5,6,7,12,18,20,24,30,35,41,48] NL = len(Lvals) lammeans = zeros(NL) lamvars = zeros(NL) for idx,L in enumerate(Lvals): lammeans[idx], lamvars[idx] = weightedAverage( L, 50 ) figure(figsize=[12,10]) errorbar(Lvals, lammeans, yerr=100lamvars,fmt='o',label='Stochastic Estimate') axhline(1.10517,color='black', label='Exact Eigenvalue') ylim([1.04,1.14]) mpl.rcParams['font.size']=18 xlabel('L') ylabel('$\lambda$(L)') title('Reproduction of Fig. 4') Explanation: VIII. The Weighted Average Rather than using the eigenvector itself to compute the eigenvalue estimate, this section introduces a functional form for an estimator. We use it to reproduce Figure 4. End of explanation # the input variables are: # -L : number of iterations to average over # -M : population # -N : length of Markov chain # -S : S+1 = number of configurations to average over at the end of the chain def stochasticReconfiguration( L, M, N, S ): # p = the probabilities of staying in state 0 or 1 p = zeros(2) w = zeros(2) p[0] = 5./6. p[1] = 3./4. # the weights affiliated with states 0 and 1 w[0] = sqrt(6./4.) w[1] = sqrt(4./6.) # all walkers start in state 0 popStates = zeros(M) popWeights = w[0]ones(M) # allocate the global weight globalWeight = zeros(N+1) # initialize for the first iteration globalWeight[0] = w[0] # iterate over the length of the Markov chain for i in range(1,N+1): # compute a set of random numbers for testing each moving in the population, at this iteration rvec = rand(M) # accumulate population weight totalWeight = 0.0 # accumulate the global weight for walker in range(M): cState = popStates[walker] if(rvec[walker]>p[cState]): popStates[walker] = mod(cState+1,2) popWeights[walker] = w[cState] totalWeight += w[cState] globalWeight[i] = totalWeight/float(M) # reconfigure cumWeights = cumsum(popWeights) rvec = rand(M) tmpStates = copy.deepcopy(popStates) tmpWeights = copy.deepcopy(popWeights) for walker in range(M): choice = bisect.bisect( cumWeights, rvec[walker]totalWeight ) popStates[walker] = tmpStates[choice] popWeights[walker] = tmpWeights[choice] Gvec = zeros(S+1) for s in range(0,S+1): Gvec[s] = prod( globalWeight[N-s-L:N-s] ) lambdaEst = dot(globalWeight[N-S:],Gvec)/sum(Gvec) return lambdaEst, globalWeight # nTrials for statistics nTrials = 10 # 2,000 samples per test LList = [0,1,2,3,4,5,6,7,12,18,20,24,30,35,41,48] LEst = zeros(len(LList)) LVar = zeros(len(LList)) for idx,pop in enumerate(LList): trialResults = zeros(nTrials) M = 30 N = 2000 for trial in range(nTrials): lE, gW = stochasticReconfiguration(L, M, N, N-1) trialResults[trial] = lE LEst[idx] = mean(trialResults) LVar[idx] = var(trialResults) figure(figsize=[12,10]) mpl.rcParams['font.size']=12 errorbar( LList, LEst, yerr=LVar, fmt='o' ) axhline(1.10517) xlabel('L') ylabel('Eigenvalue') title('For M=30 walkers, the small L bias is removed') ylim([1.04,1.14]) # nTrials for statistics nTrials = 10 # 2,000 samples per test LList = [0,1,2,3,4,5,6,7,12,18,20,24,30,35,41,48] LEst = zeros(len(LList)) LVar = zeros(len(LList)) for idx,pop in enumerate(LList): trialResults = zeros(nTrials) M = 2 N = 2000 for trial in range(nTrials): lE, gW = stochasticReconfiguration(L, M, N, N-1) trialResults[trial] = lE LEst[idx] = mean(trialResults) LVar[idx] = var(trialResults) figure(figsize=[12,10]) mpl.rcParams['font.size']=12 errorbar( LList, LEst, yerr=LVar, fmt='o' ) axhline(1.10517) xlabel('L') ylabel('Eigenvalue') title('For M=2 walkers, the small L bias is removed (and made worse)') ylim([1.04,1.14]) Explanation: Here we see the fundamental tradeoff that we have to deal with. Even for a Markov Chain with 20,000 iterations we have a choice between problems: If we truncate the product of weights to L<10, we have small variance but statistical bias. If we let the product of weights increase to encompass the whole chain, the variance will grow exponentially with L. Reconfiguration is the solution to this problem. IX, X, and XI. Carrying Many Configurations Simultaneously (and More) The solution to these problems is to carry many walkers together, and to assign a global weight to the group of walkers. The algorithm implemented goes through the following: Create a population of walkers and sum up their total weight. Randomly move each walker individually as before. Compute the population averaged weight, which will be used in the estimator. Choose to copy (or not copy) walkers among this fixed population based upon their relative weights. Repeat. The basic idea here is that a single walker is liable to have weights that explode. Rather than relying on these individual weights, we aggregate them every so often (in this case every iteration) and reconfigure the walker population relative to their cumulative weights. This has the net effect of damping out huge fluctuations in the weights, while introducing a statistical bias that scales inversely with the walker population. End of explanation
12,427	Given the following text description, write Python code to implement the functionality described below step by step Description: Regression Week 4 Step1: If we want to do any "feature engineering" like creating new features or adjusting existing ones we should do this directly using the SFrames as seen in the first notebook of Week 2. For this notebook, however, we will work with the existing features. Loading and Plotting the house sales data Step2: Import useful functions from previous notebook As in Week 2, we convert the SFrame into a 2D Numpy array. Copy and paste get_num_data() from the second notebook of Week 2. Step3: Also, copy and paste the predict_output() function to compute the predictions for an entire matrix of features given the matrix and the weights Step4: Computing the Derivative We are now going to move to computing the derivative of the regression cost function. Recall that the cost function is the sum over the data points of the squared difference between an observed output and a predicted output, plus the L2 penalty term. Cost(w) = SUM[ (prediction - output)^2 ] + l2_penalty*(w[0]^2 + w[1]^2 + ... + w[k]^2). Since the derivative of a sum is the sum of the derivatives, we can take the derivative of the first part (the RSS) as we did in the notebook for the unregularized case in Week 2 and add the derivative of the regularization part. As we saw, the derivative of the RSS with respect to w[i] can be written as Step5: To test your feature derivartive run the following Step6: Gradient Descent Now we will write a function that performs a gradient descent. The basic premise is simple. Given a starting point we update the current weights by moving in the negative gradient direction. Recall that the gradient is the direction of increase and therefore the negative gradient is the direction of decrease and we're trying to minimize a cost function. The amount by which we move in the negative gradient direction is called the 'step size'. We stop when we are 'sufficiently close' to the optimum. Unlike in Week 2, this time we will set a maximum number of iterations and take gradient steps until we reach this maximum number. If no maximum number is supplied, the maximum should be set 100 by default. (Use default parameter values in Python.) With this in mind, complete the following gradient descent function below using your derivative function above. For each step in the gradient descent, we update the weight for each feature before computing our stopping criteria. Step7: Visualizing effect of L2 penalty The L2 penalty gets its name because it causes weights to have small L2 norms than otherwise. Let's see how large weights get penalized. Let us consider a simple model with 1 feature Step8: Load the training set and test set. Step9: In this part, we will only use 'sqft_living' to predict 'price'. Use the get_numpy_data function to get a Numpy versions of your data with only this feature, for both the train_data and the test_data. Step10: Let's set the parameters for our optimization Step11: First, let's consider no regularization. Set the l2_penalty to 0.0 and run your ridge regression algorithm to learn the weights of your model. Call your weights Step12: Next, let's consider high regularization. Set the l2_penalty to 1e11 and run your ridge regression algorithm to learn the weights of your model. Call your weights Step13: This code will plot the two learned models. (The green line is for the model with no regularization and the red line is for the one with high regularization.) Step14: Compute the RSS on the TEST data for the following three sets of weights Step15: QUIZ QUESTIONS Q1 Step16: Q2 Step17: Q3 Step18: Initial weights learned with no regularization performed best on the Test Set (lowest RSS value) Running a multiple regression with L2 penalty Let us now consider a model with 2 features Step19: We need to re-inialize the weights, since we have one extra parameter. Let us also set the step size and maximum number of iterations. Step20: First, let's consider no regularization. Set the l2_penalty to 0.0 and run your ridge regression algorithm to learn the weights of your model. Call your weights Step21: Next, let's consider high regularization. Set the l2_penalty to 1e11 and run your ridge regression algorithm to learn the weights of your model. Call your weights Step22: Compute the RSS on the TEST data for the following three sets of weights Step23: Predict the house price for the 1st house in the test set using the no regularization and high regularization models. (Remember that python starts indexing from 0.) How far is the prediction from the actual price? Which weights perform best for the 1st house? Step24: Weights with high regularization perform best on 1st house in Test Set QUIZ QUESTIONS Q1 Step25: Q2	Python Code: import graphlab import numpy as np import pandas as pd from sklearn import linear_model import matplotlib as mpl import matplotlib.pyplot as plt import seaborn as sns sns.set_style('darkgrid') %matplotlib inline Explanation: Regression Week 4: Ridge Regression (gradient descent) In this notebook, we will implement ridge regression via gradient descent. You will: * Convert an SFrame into a Numpy array * Write a Numpy function to compute the derivative of the regression weights with respect to a single feature * Write gradient descent function to compute the regression weights given an initial weight vector, step size, tolerance, and L2 penalty Importing Libraries End of explanation sales = graphlab.SFrame('kc_house_data.gl/') plt.figure(figsize=(8,6)) plt.plot(sales['sqft_living'], sales['price'],'.') plt.xlabel('Living Area (ft^2)', fontsize=16) plt.ylabel('House Price ($)', fontsize=16) plt.title('King County, Seattle House Price Data', fontsize=18) plt.axis([0.0, 14000.0, 0.0, 8000000.0]) plt.show() Explanation: If we want to do any "feature engineering" like creating new features or adjusting existing ones we should do this directly using the SFrames as seen in the first notebook of Week 2. For this notebook, however, we will work with the existing features. Loading and Plotting the house sales data End of explanation def get_numpy_data(input_sframe, features, output): input_sframe['constant'] = 1 # Adding column 'constant' to input SFrame with all values = 1.0 features = ['constant'] + features # Adding 'constant' to List of features # Selecting the columns for the feature_matrux and output_array features_sframe = input_sframe[features] output_sarray = input_sframe[output] # Converting sframes to numpy.ndarrays feature_matrix = features_sframe.to_numpy() output_array = output_sarray.to_numpy() return(feature_matrix, output_array) Explanation: Import useful functions from previous notebook As in Week 2, we convert the SFrame into a 2D Numpy array. Copy and paste get_num_data() from the second notebook of Week 2. End of explanation def predict_output(feature_matrix, weights): predictions = np.dot(feature_matrix, weights) return predictions Explanation: Also, copy and paste the predict_output() function to compute the predictions for an entire matrix of features given the matrix and the weights: End of explanation def feature_derivative_ridge(errors, feature, weight, l2_penalty, feature_is_constant): # If feature_is_constant is True, derivative is twice the dot product of errors and feature if feature_is_constant==True: derivative = 2.0np.dot(errors, feature) # Otherwise, derivative is twice the dot product plus 2l2_penaltyweight else: derivative = 2.0np.dot(errors, feature) + 2.0l2_penaltyweight return derivative Explanation: Computing the Derivative We are now going to move to computing the derivative of the regression cost function. Recall that the cost function is the sum over the data points of the squared difference between an observed output and a predicted output, plus the L2 penalty term. Cost(w) = SUM[ (prediction - output)^2 ] + l2_penalty(w[0]^2 + w[1]^2 + ... + w[k]^2). Since the derivative of a sum is the sum of the derivatives, we can take the derivative of the first part (the RSS) as we did in the notebook for the unregularized case in Week 2 and add the derivative of the regularization part. As we saw, the derivative of the RSS with respect to w[i] can be written as: 2SUM[ error[feature_i] ]. The derivative of the regularization term with respect to w[i] is: 2l2_penaltyw[i]. Summing both, we get 2SUM[ error[feature_i] ] + 2l2_penaltyw[i]. That is, the derivative for the weight for feature i is the sum (over data points) of 2 times the product of the error and the feature itself, plus 2l2_penaltyw[i]. We will not regularize the constant. Thus, in the case of the constant, the derivative is just twice the sum of the errors (without the 2l2_penaltyw[0] term). Recall that twice the sum of the product of two vectors is just twice the dot product of the two vectors. Therefore the derivative for the weight for feature_i is just two times the dot product between the values of feature_i and the current errors, plus 2l2_penaltyw[i]. With this in mind complete the following derivative function which computes the derivative of the weight given the value of the feature (over all data points) and the errors (over all data points). To decide when to we are dealing with the constant (so we don't regularize it) we added the extra parameter to the call feature_is_constant which you should set to True when computing the derivative of the constant and False otherwise. End of explanation (example_features, example_output) = get_numpy_data(sales, ['sqft_living'], 'price') my_weights = np.array([1., 10.]) test_predictions = predict_output(example_features, my_weights) errors = test_predictions - example_output # prediction errors # next two lines should print the same values print feature_derivative_ridge(errors, example_features[:,1], my_weights[1], 1, False) print np.sum(errorsexample_features[:,1])2+20. print '' # next two lines should print the same values print feature_derivative_ridge(errors, example_features[:,0], my_weights[0], 1, True) print np.sum(errors)2. Explanation: To test your feature derivartive run the following: End of explanation def ridge_regression_gradient_descent(feature_matrix, output, initial_weights, step_size, l2_penalty, max_iterations): weights = np.array(initial_weights) # make sure it's a numpy array iteration_count = 0 #while not reached maximum number of iterations: while iteration_count < max_iterations: predictions = predict_output(feature_matrix, weights) # computing predictions w/ feature_matrix and weights errors = predictions - output # compute the errors as predictions - output # loop over each weight for i in xrange(len(weights)): # Recall that feature_matrix[:,i] is the feature column associated with weights[i] # compute the derivative for weight[i]. #(Remember: when i=0, you are computing the derivative of the constant!) if i == 0: derivative = feature_derivative_ridge(errors, feature_matrix[:,0], weights[0], l2_penalty, True) else: derivative = feature_derivative_ridge(errors, feature_matrix[:,i], weights[i], l2_penalty, False) weights[i] = weights[i] - step_sizederivative # Incrementing the iteration count iteration_count += 1 return weights Explanation: Gradient Descent Now we will write a function that performs a gradient descent. The basic premise is simple. Given a starting point we update the current weights by moving in the negative gradient direction. Recall that the gradient is the direction of increase and therefore the negative gradient is the direction of decrease and we're trying to minimize a cost function. The amount by which we move in the negative gradient direction is called the 'step size'. We stop when we are 'sufficiently close' to the optimum. Unlike in Week 2, this time we will set a maximum number of iterations and take gradient steps until we reach this maximum number. If no maximum number is supplied, the maximum should be set 100 by default. (Use default parameter values in Python.) With this in mind, complete the following gradient descent function below using your derivative function above. For each step in the gradient descent, we update the weight for each feature before computing our stopping criteria. End of explanation simple_features = ['sqft_living'] my_output = 'price' Explanation: Visualizing effect of L2 penalty The L2 penalty gets its name because it causes weights to have small L2 norms than otherwise. Let's see how large weights get penalized. Let us consider a simple model with 1 feature: End of explanation train_data,test_data = sales.random_split(.8,seed=0) Explanation: Load the training set and test set. End of explanation (simple_feature_matrix, output) = get_numpy_data(train_data, simple_features, my_output) (simple_test_feature_matrix, test_output) = get_numpy_data(test_data, simple_features, my_output) Explanation: In this part, we will only use 'sqft_living' to predict 'price'. Use the get_numpy_data function to get a Numpy versions of your data with only this feature, for both the train_data and the test_data. End of explanation initial_weights = np.array([0.0, 0.0]) step_size = 1e-12 max_iterations=1000 Explanation: Let's set the parameters for our optimization: End of explanation l2_penalty = 0.0 simple_weights_0_penalty = ridge_regression_gradient_descent(simple_feature_matrix, output, initial_weights, step_size, l2_penalty, max_iterations) Explanation: First, let's consider no regularization. Set the l2_penalty to 0.0 and run your ridge regression algorithm to learn the weights of your model. Call your weights: simple_weights_0_penalty we'll use them later. End of explanation l2_penalty = 1.0e11 simple_weights_high_penalty = ridge_regression_gradient_descent(simple_feature_matrix, output, initial_weights, step_size, l2_penalty, max_iterations) Explanation: Next, let's consider high regularization. Set the l2_penalty to 1e11 and run your ridge regression algorithm to learn the weights of your model. Call your weights: simple_weights_high_penalty we'll use them later. End of explanation plt.figure(figsize=(8,6)) plt.plot(simple_feature_matrix[:,1],output,'.', label= 'House Price Data') plt.hold(True) plt.plot(simple_feature_matrix[:,1], predict_output(simple_feature_matrix, simple_weights_0_penalty),'-', label= 'No L2 Penalty') plt.plot(simple_feature_matrix[:,1], predict_output(simple_feature_matrix, simple_weights_high_penalty),'-', label= 'Large L2 Penalty') plt.hold(False) plt.legend(loc='upper left', fontsize=16) plt.xlabel('Living Area (ft^2)', fontsize=16) plt.ylabel('House Price ($)', fontsize=16) plt.title('King County, Seattle House Price Data', fontsize=18) plt.axis([0.0, 14000.0, 0.0, 8000000.0]) plt.show() Explanation: This code will plot the two learned models. (The green line is for the model with no regularization and the red line is for the one with high regularization.) End of explanation test_pred_weights_0 = predict_output(simple_test_feature_matrix, initial_weights) RSS_test_weights_0 = sum( (test_output - test_pred_weights_0)2.0 ) test_pred_no_reg = predict_output(simple_test_feature_matrix, simple_weights_0_penalty) RSS_test_no_reg = sum( (test_output - test_pred_no_reg)2.0 ) test_pred_high_reg = predict_output(simple_test_feature_matrix, simple_weights_high_penalty) RSS_test_high_reg = sum( (test_output - test_pred_high_reg)2.0 ) Explanation: Compute the RSS on the TEST data for the following three sets of weights: 1. The initial weights (all zeros) 2. The weights learned with no regularization 3. The weights learned with high regularization Which weights perform best? End of explanation print 'No Regulatization sqft_living weight: %.1f' %(simple_weights_0_penalty[1]) print 'High Regulatization sqft_living weight: %.1f' %(simple_weights_high_penalty[1]) Explanation: QUIZ QUESTIONS Q1: What is the value of the coefficient for sqft_living that you learned with no regularization, rounded to 1 decimal place? What about the one with high regularization? End of explanation print 'Line with No Regularization is steeper' Explanation: Q2: Comparing the lines you fit with the with no regularization versus high regularization, which one is steeper? End of explanation print 'Test set RSS with initial weights all set to 0.0: %.1e' %(RSS_test_weights_0) print 'Test set RSS with initial weights set to weights learned with no regularization: %.1e' %(RSS_test_no_reg) print 'Test set RSS with initial weights set to weights learned with high regularization: %.1e' %(RSS_test_high_reg) Explanation: Q3: What are the RSS on the test data for each of the set of weights above (initial, no regularization, high regularization)? End of explanation model_features = ['sqft_living', 'sqft_living15'] # sqft_living15 is the average squarefeet for the nearest 15 neighbors. my_output = 'price' (feature_matrix, output) = get_numpy_data(train_data, model_features, my_output) (test_feature_matrix, test_output) = get_numpy_data(test_data, model_features, my_output) Explanation: Initial weights learned with no regularization performed best on the Test Set (lowest RSS value) Running a multiple regression with L2 penalty Let us now consider a model with 2 features: ['sqft_living', 'sqft_living15']. First, create Numpy versions of your training and test data with these two features. End of explanation initial_weights = np.array([0.0,0.0,0.0]) step_size = 1e-12 max_iterations = 1000 Explanation: We need to re-inialize the weights, since we have one extra parameter. Let us also set the step size and maximum number of iterations. End of explanation l2_penalty = 0.0 multiple_weights_0_penalty = ridge_regression_gradient_descent(feature_matrix, output, initial_weights, step_size, l2_penalty, max_iterations) Explanation: First, let's consider no regularization. Set the l2_penalty to 0.0 and run your ridge regression algorithm to learn the weights of your model. Call your weights: multiple_weights_0_penalty End of explanation l2_penalty = 1.0e11 multiple_weights_high_penalty = ridge_regression_gradient_descent(feature_matrix, output, initial_weights, step_size, l2_penalty, max_iterations) Explanation: Next, let's consider high regularization. Set the l2_penalty to 1e11 and run your ridge regression algorithm to learn the weights of your model. Call your weights: multiple_weights_high_penalty End of explanation test_pred_mul_feat_weights_0 = predict_output(test_feature_matrix, initial_weights) RSS_test_mul_feat_weights_0 = sum( (test_output - test_pred_mul_feat_weights_0)2.0 ) test_pred_mul_feat_no_reg = predict_output(test_feature_matrix, multiple_weights_0_penalty) RSS_test_mul_feat_no_reg = sum( (test_output - test_pred_mul_feat_no_reg)2.0 ) test_pred_mul_feat_high_reg = predict_output(test_feature_matrix, multiple_weights_high_penalty) RSS_test_mul_feat_high_reg = sum( (test_output - test_pred_mul_feat_high_reg)*2.0 ) Explanation: Compute the RSS on the TEST data for the following three sets of weights: 1. The initial weights (all zeros) 2. The weights learned with no regularization 3. The weights learned with high regularization Which weights perform best? End of explanation print 'Pred. price of 1st house in Test Set with weights learned with no reg.: %.2f' %(test_pred_mul_feat_no_reg[0]) print 'Pred. price of 1st house in Test Set with weights learned with high reg.: %.2f' %(test_pred_mul_feat_high_reg[0]) print 'Pred. price - actual prize of 1st house in Test Set, using weights w/ no reg.: %.2f' %(abs(test_output[0] - test_pred_mul_feat_no_reg[0])) print 'Pred. price - actual prize of 1st house in Test Set, using weights w/ high reg.: %.2f' %(abs(test_output[0] - test_pred_mul_feat_high_reg[0])) Explanation: Predict the house price for the 1st house in the test set using the no regularization and high regularization models. (Remember that python starts indexing from 0.) How far is the prediction from the actual price? Which weights perform best for the 1st house? End of explanation print 'No Regulatization sqft_living weight: %.1f' %(multiple_weights_0_penalty[1]) print 'High Regulatization sqft_living weight: %.1f' %(multiple_weights_high_penalty[1]) Explanation: Weights with high regularization perform best on 1st house in Test Set QUIZ QUESTIONS Q1: What is the value of the coefficient for sqft_living that you learned with no regularization, rounded to 1 decimal place? What about the one with high regularization? End of explanation print 'Test set RSS with initial weights all set to 0.0: %.1e' %(RSS_test_mul_feat_weights_0) print 'Test set RSS with initial weights set to weights learned with no regularization: %.1e' %(RSS_test_mul_feat_no_reg) print 'Test set RSS with initial weights set to weights learned with high regularization: %.1e' %(RSS_test_mul_feat_high_reg) Explanation: Q2: What are the RSS on the test data for each of the set of weights above (initial, no regularization, high regularization)? End of explanation
12,428	Given the following text description, write Python code to implement the functionality described below step by step Description: Azimuthal Integral Introduction This tutorial demonstrates how to acquire an azimuthal integral profile from a multidimensional data set in pyXem. The data set is a 10x10x256x256 data set of a polycrystalline gold film acquired using a Medipix3 256 by 256 pixel detector. This functionality has been checked to run in pyxem-0.13.2 (May 2021). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here Step1: Assert that pyxem is properly loaded into hyperspy.. Step2: Load polycrystalline SED data Step3: Check the data size and type. It is also a good idea to look at your data as well just to make sure it loaded properly. Then we will set the diffraction and scan calibration based on values found by calibrating the dataset to a known standard. Step4: <a id='c1'></a> Case 1 Step5: <a id='c2'></a> Case 2 Step6: Calibration Step7: <a id='c3'></a> Additional Parameters Step8: Let's take a different example using an obviously distorted ring pattern. The goal is to apply an affine transformation such that the rings become lines with minimal distortion. In general just appling a azimuthal integration2d to your diffraction image is a good way to determine if there is any distortion in the image. Waves in the image are much more obvious than slight ellipticity in an image with cartesian coodinates. Step9: Masking Below we show how a mask might be applied. For the time being it is much faster to have mask, center and affine be numpy arrays rather than BaseSignals as making a new integration object for each is quite a costly computation. Step10: Methods This final section gives a breif explination of the different methods avaible through pyfai. They all also have the option to correctSolidAngle. It is best just to show you the output for each method and from there you can determine which you might perfer. The correctSolid angle parameter is largely unimportant in electron microcopy becuase of the size of the Ewald's Sphere	Python Code: %matplotlib inline import hyperspy.api as hs import numpy as np import matplotlib.pyplot as plt Explanation: Azimuthal Integral Introduction This tutorial demonstrates how to acquire an azimuthal integral profile from a multidimensional data set in pyXem. The data set is a 10x10x256x256 data set of a polycrystalline gold film acquired using a Medipix3 256 by 256 pixel detector. This functionality has been checked to run in pyxem-0.13.2 (May 2021). Bugs are always possible, do not trust the code blindly, and if you experience any issues please report them here: https://github.com/pyxem/pyxem-demos/issues Contents At this point things are mostly set up. There are a couple of different work flows moving forward which allow the user a fair degree of control. In general the key parameter is the unit keyword in the integration. Let's show the different use cases and you can choose which works the best into your workflow. Case 1 and Case 2 should be suffient for most use cases but case 3 gives you additional functionality by allowing to user to predefine their detector to thier specifications. <a href='#c0'> Loading and Inspection</a> <a href='#c1'> PyXEM units based integration</a> <a href='#c2'> PyFAI units based integration</a> <a href='#c3'> Additional Parameters (center, affine, masks, methods)</a> <a id='c0'></a> 0. Loading and Inspection Import pyxem and other required libraries End of explanation print(hs.print_known_signal_types()) Explanation: Assert that pyxem is properly loaded into hyperspy.. End of explanation dp = hs.load("./data/07/azimuthal_integration.hspy", signal_type='electron_diffraction') Explanation: Load polycrystalline SED data End of explanation calib = 0.009197 dp.diffraction_calibration=calib dp.scan_calibration= 5 dp.axes_manager print("Signal type and dimensions: ", dp) dp.inav[1,1].plot(vmax=1000) plt.show() Explanation: Check the data size and type. It is also a good idea to look at your data as well just to make sure it loaded properly. Then we will set the diffraction and scan calibration based on values found by calibrating the dataset to a known standard. End of explanation dp.unit = "k_A^-1" dp.beam_energy = 200 # in 200 keV dp.axes_manager # see how the units now are set for the signal axis. #if we want to see more about the function dp.set_ai? dp.set_ai() integration = dp.get_azimuthal_integral1d(npt=100, ) integration2d = dp.get_azimuthal_integral2d(npt=100) # Excluding the zero beam... integration.inav[0,0].isig[10:].plot() integration2d.inav[0,0].isig[:,10:].plot() plt.show() Explanation: <a id='c1'></a> Case 1: PyXEM units based integration. The key difference between Case 1 and Case 2 is that for Case 1 the units are already set in PyXEM so the detector distance and dectector set up are just handled by creating a generic set up that aligns with how pyXEM deals with calibrations. All of these integrations are done by pyFAI so it might be worth it to discuss how pyFAI does their integration. PyFAI Integration In pyFAI there are three geometries that are of interest. The best way to think about them are as two concentric spheres with a real detector at the apex of one sphere and an imaginary detector at the apex of the other sphere. This gives rise to two corrections that are applied to the data. 1- correctSolidAngle: This is to correct for a sphere being projected onto a flat detector. It takes and makes pixel values farther from the center more intense to account for their lower intensity. 2- Ewald Sphere Correction: This takes into account the change in intensity for dealing with the ewald sphere as well as the distorition in the spacing. What connects these two spheres is that their solid angles are equal, which gives rise to the 2th_deg and 2th_rad formalisim. By their nature these two ignore the ewald To simplify things when pyXEM deals with this integration we assume a flat detector and constant radius of one sphere and then just change the pixel size of the detector to The key things that need to be set are the "unit" and the "beam_energy" which are both attribuites that can be set with: dp.unit = "k_A^-1" dp.beam_energy = 200 # keV The other acceptable units are "k_nm^-1", "q_nm^-1", "q_A^-1", "2th_deg", "2th_rad". - "q_nm^-1" (q inverse spacing, mostly used with Xray data) - "q_A^-1" - "k_nm^-1" (k inverse spacing, mostly used for electron diffraction data, factor of 2 pi less than q) - "k_A^-1" - "2th_deg" (degree spacing, doesn't account for ewald sphere) - "2th_rad" (radial spacing, doesn't account for ewald sphere) Note: For electron diffraction the Ewald sphere is largely not considered. Rather some reflection in a standard material is used to calibrate the pixel size. Then that pixel size is used consistantly assuming a constant. This is mostly correct, and largely what we do in the first case expect we use that calibration to define one point on the Ewald sphere and then calculate the scale from there. End of explanation from pyxem.detectors import Medipix256x256Detector detector = Medipix256x256Detector() print(detector) Explanation: <a id='c2'></a> Case 2: PyFAI based Integration The second case involves setting up your own detector, detector distance, wavelength etc. If you have a good understanding of pyFAI then this might actually be the best route. There are a significant number of parameters to play with when using pyFAI, however, so there is a litte bit of extra set up involved and in my opinion a little more difficulty in getting more advanced cases. There are a couple of detectors already set up in pyxem dectectors and more in pyFAI so check there first to see what other people have done. End of explanation # Reading the camera length from microscope camera_length = 0.24 #in metres # Calculating camera length from real pixel size and recoporical pixel size wavelength = 2.5079e-12 pix_size = 55e-6 #change to 1 if using the GenericFlatDetector() camera_length = pix_size / (wavelength * calib * 1e10) print('Camera Length:', camera_length) from pyFAI.azimuthalIntegrator import AzimuthalIntegrator center=(128,128) ai = AzimuthalIntegrator(dist=camera_length, detector=detector, wavelength=wavelength) ai.setFit2D(directDist=camera_length*1000, centerX=center[1], centerY=center[0]) dp.metadata.set_item("Signal.ai", ai) integration1d = dp.get_azimuthal_integral1d(npt =100) integration2d = dp.get_azimuthal_integral2d(npt =100) integration1d.inav[1,1].isig[0.2:].plot() integration2d.inav[1,1].isig[:, 0.2:].plot() Explanation: Calibration: In addition to specifying the detector, to accurately calculate the curvature of the Ewald Sphere, it is important to specify a calibration. In addition, the wavelength is specified to do that calculation. The calibration is calculated by knowing the camera length. Alternatively, by assuming a no curvature in the detector, it is possible to calculate the camera length from an "inverse angstroms per pixel" calibration value. We suggest calibrating to a gold pattern for a calibration value and using the latter (for electron microscopy). End of explanation affine = np.array([[0.99978285, 0.00341758, 0.], [0.00341758, 0.94621262, 0.], [0., 0., 1.]]) dp.set_ai(affine=affine) integration = dp.get_azimuthal_integral1d(npt=100) integration2d = dp.get_azimuthal_integral2d(npt=100) # Excluding the zero beam... integration.inav[0,0].isig[0.2:].plot() integration2d.inav[0,0].isig[:,.2:].plot() plt.show() Explanation: <a id='c3'></a> Additional Parameters: There are a couple of different thing you can play around with at this point. For one there are three additional parameters that are useful for more advanced calibrations. These will work in all three of the cases but with case 3 some of these parameters can be intialized as you instantiate the detector. For the most part though these should be passed in as the method is calls. The three parameters are: center - The center of the diffraction pattern if it is not the center of the image affine - A 3x3 matrix which represents an affine transformation to the singal. mask - A mask with the same size as the singal. These three parameters can also be passed as BaseSignal objects from hyperspy and with the same size navigation axes as the original signal. In this case they will be iterated with the diffraction signal and a different calibration is applied to every diffraciton pattern Affine This applies an affine transfromation to the dataset before the integration. End of explanation from diffsims.utils.ring_pattern_utils import generate_ring_pattern x0 = [95, 1200, 2.8, 450, 1.5, 10] ring_data = generate_ring_pattern( image_size=256, mask=True, mask_radius=10, scale=x0[0], amplitude=x0[1], spread=x0[2], direct_beam_amplitude=x0[3], asymmetry=x0[4], rotation=x0[5], ) import pyxem import numpy as np d =pyxem.signals.ElectronDiffraction2D(data=ring_data) a = np.asarray( [[1.06651526, 0.10258988, 0.0], [0.10258988, 1.15822961, 0.0], [0.0, 0.0, 1.0]] ) d.plot() d.unit = "2th_deg" d.set_ai(affine=a) d.get_azimuthal_integral2d(npt=100, correctSolidAngle=False).plot() Explanation: Let's take a different example using an obviously distorted ring pattern. The goal is to apply an affine transformation such that the rings become lines with minimal distortion. In general just appling a azimuthal integration2d to your diffraction image is a good way to determine if there is any distortion in the image. Waves in the image are much more obvious than slight ellipticity in an image with cartesian coodinates. End of explanation mask = dp.get_direct_beam_mask(radius=30) integration = dp.get_azimuthal_integral1d(npt=100, mask=mask.data) integration2d = dp.get_azimuthal_integral2d(npt=100, mask=mask.data) integration.inav[1,1].isig[:].plot() integration2d.inav[1,1].isig[:,:].plot() Explanation: Masking Below we show how a mask might be applied. For the time being it is much faster to have mask, center and affine be numpy arrays rather than BaseSignals as making a new integration object for each is quite a costly computation. End of explanation methods = ["numpy", "cython", "BBox","splitpixel", "lut", "csr", "nosplit_csr", "full_csr"] littledp = dp.inav[1,1] import time integrations= [] times = [] for method in methods: tic = time.time() no_sa = littledp.get_azimuthal_integral2d(npt=100, method=method, correctSolidAngle=False) toc = time.time() sa = littledp.get_azimuthal_integral2d(npt=100, method=method, correctSolidAngle=True) toc2 =time.time() integrations.append(no_sa) integrations.append(sa) times.append([toc-tic, toc2-toc]) lab = ["numpy","numpy_SA", "cython","cython_SA", "BBox", "BBox_SA", "splitpixel","splitpixel_SA", "lut","lut_SA", "csr","csr_SA", "nosplit_csr","nosplit_csr_SA", "full_csr","full_csr_SA"] lab_time = [ l+" ("+str(round(t[0],2))+" sec)" for l,t in zip(lab,times)] f = plt.figure(figsize=(20,30)) hs.plot.plot_images(integrations,vmax=(1000), per_row=2, fig=f, label=lab_time) plt.show() Explanation: Methods This final section gives a breif explination of the different methods avaible through pyfai. They all also have the option to correctSolidAngle. It is best just to show you the output for each method and from there you can determine which you might perfer. The correctSolid angle parameter is largely unimportant in electron microcopy becuase of the size of the Ewald's Sphere End of explanation
12,429	Given the following text description, write Python code to implement the functionality described below step by step Description: Parameter selection, Validation & Testing Most models have parameters that influence how complex a model they can learn. Remember using KNeighborsRegressor. If we change the number of neighbors we consider, we get a smoother and smoother prediction Step1: In the above figure, we see fits for three different values of n_neighbors. For n_neighbors=2, the data is overfit, the model is too flexible and can adjust too much to the noise in the training data. For n_neighbors=20, the model is not flexible enough, and can not model the variation in the data appropriately. In the middle, for n_neighbors = 5, we have found a good mid-point. It fits the data fairly well, and does not suffer from the overfit or underfit problems seen in the figures on either side. What we would like is a way to quantitatively identify overfit and underfit, and optimize the hyperparameters (in this case, the polynomial degree d) in order to determine the best algorithm. We trade off remembering too much about the particularities and noise of the training data vs. not modeling enough of the variability. This is a trade-off that needs to be made in basically every machine learning application and is a central concept, called bias-variance-tradeoff or "overfitting vs underfitting". Hyperparameters, Over-fitting, and Under-fitting Unfortunately, there is no general rule how to find the sweet spot, and so machine learning practitioners have to find the best trade-off of model-complexity and generalization by trying several parameter settings. Most commonly this is done using a brute force search, for example over multiple values of n_neighbors Step2: There is a function in scikit-learn, called validation_plot to reproduce the cartoon figure above. It plots one parameter, such as the number of neighbors, against training and validation error (using cross-validation) Step3: Note that many neighbors mean a "smooth" or "simple" model, so the plot is the mirror image of the diagram above. If multiple parameters are important, like the parameters C and gamma in an SVM (more about that later), all possible combinations are tried Step4: As this is such a very common pattern, there is a built-in class for this in scikit-learn, GridSearchCV. GridSearchCV takes a dictionary that describes the parameters that should be tried and a model to train. The grid of parameters is defined as a dictionary, where the keys are the parameters and the values are the settings to be tested. Step5: One of the great things about GridSearchCV is that it is a meta-estimator. It takes an estimator like SVR above, and creates a new estimator, that behaves exactly the same - in this case, like a regressor. So we can call fit on it, to train it Step6: What fit does is a bit more involved then what we did above. First, it runs the same loop with cross-validation, to find the best parameter combination. Once it has the best combination, it runs fit again on all data passed to fit (without cross-validation), to built a single new model using the best parameter setting. Then, as with all models, we can use predict or score Step7: You can inspect the best parameters found by GridSearchCV in the best_params_ attribute, and the best score in the best_score_ attribute Step8: There is a problem with using this score for evaluation, however. You might be making what is called a multiple hypothesis testing error. If you try very many parameter settings, some of them will work better just by chance, and the score that you obtained might not reflect how your model would perform on new unseen data. Therefore, it is good to split off a separate test-set before performing grid-search. This pattern can be seen as a training-validation-test split, and is common in machine learning Step9: Some practitioners go for an easier scheme, splitting the data simply into three parts, training, validation and testing. This is a possible alternative if your training set is very large, or it is infeasible to train many models using cross-validation because training a model takes very long. You can do this with scikit-learn for example by splitting of a test-set and then applying GridSearchCV with ShuffleSplit cross-validation with a single iteration	Python Code: from figures import plot_kneighbors_regularization plot_kneighbors_regularization() Explanation: Parameter selection, Validation & Testing Most models have parameters that influence how complex a model they can learn. Remember using KNeighborsRegressor. If we change the number of neighbors we consider, we get a smoother and smoother prediction: End of explanation from sklearn.cross_validation import cross_val_score, KFold from sklearn.neighbors import KNeighborsRegressor # generate toy dataset: x = np.linspace(-3, 3, 100) y = np.sin(4 * x) + x + np.random.normal(size=len(x)) X = x[:, np.newaxis] cv = KFold(n=len(x), shuffle=True) # for each parameter setting do cross_validation: for n_neighbors in [1, 3, 5, 10, 20]: scores = cross_val_score(KNeighborsRegressor(n_neighbors=n_neighbors), X, y, cv=cv) print("n_neighbors: %d, average score: %f" % (n_neighbors, np.mean(scores))) Explanation: In the above figure, we see fits for three different values of n_neighbors. For n_neighbors=2, the data is overfit, the model is too flexible and can adjust too much to the noise in the training data. For n_neighbors=20, the model is not flexible enough, and can not model the variation in the data appropriately. In the middle, for n_neighbors = 5, we have found a good mid-point. It fits the data fairly well, and does not suffer from the overfit or underfit problems seen in the figures on either side. What we would like is a way to quantitatively identify overfit and underfit, and optimize the hyperparameters (in this case, the polynomial degree d) in order to determine the best algorithm. We trade off remembering too much about the particularities and noise of the training data vs. not modeling enough of the variability. This is a trade-off that needs to be made in basically every machine learning application and is a central concept, called bias-variance-tradeoff or "overfitting vs underfitting". Hyperparameters, Over-fitting, and Under-fitting Unfortunately, there is no general rule how to find the sweet spot, and so machine learning practitioners have to find the best trade-off of model-complexity and generalization by trying several parameter settings. Most commonly this is done using a brute force search, for example over multiple values of n_neighbors: End of explanation from sklearn.learning_curve import validation_curve n_neighbors = [1, 3, 5, 10, 20, 50] train_errors, test_errors = validation_curve(KNeighborsRegressor(), X, y, param_name="n_neighbors", param_range=n_neighbors) plt.plot(n_neighbors, train_errors.mean(axis=1), label="train error") plt.plot(n_neighbors, test_errors.mean(axis=1), label="test error") plt.legend(loc="best") Explanation: There is a function in scikit-learn, called validation_plot to reproduce the cartoon figure above. It plots one parameter, such as the number of neighbors, against training and validation error (using cross-validation): End of explanation from sklearn.cross_validation import cross_val_score, KFold from sklearn.svm import SVR # each parameter setting do cross_validation: for C in [0.001, 0.01, 0.1, 1, 10]: for gamma in [0.001, 0.01, 0.1, 1]: scores = cross_val_score(SVR(C=C, gamma=gamma), X, y, cv=cv) print("C: %f, gamma: %f, average score: %f" % (C, gamma, np.mean(scores))) Explanation: Note that many neighbors mean a "smooth" or "simple" model, so the plot is the mirror image of the diagram above. If multiple parameters are important, like the parameters C and gamma in an SVM (more about that later), all possible combinations are tried: End of explanation from sklearn.grid_search import GridSearchCV param_grid = {'C': [0.001, 0.01, 0.1, 1, 10], 'gamma': [0.001, 0.01, 0.1, 1]} grid = GridSearchCV(SVR(), param_grid=param_grid, cv=cv, verbose=3) Explanation: As this is such a very common pattern, there is a built-in class for this in scikit-learn, GridSearchCV. GridSearchCV takes a dictionary that describes the parameters that should be tried and a model to train. The grid of parameters is defined as a dictionary, where the keys are the parameters and the values are the settings to be tested. End of explanation grid.fit(X, y) Explanation: One of the great things about GridSearchCV is that it is a meta-estimator. It takes an estimator like SVR above, and creates a new estimator, that behaves exactly the same - in this case, like a regressor. So we can call fit on it, to train it: End of explanation grid.predict(X) Explanation: What fit does is a bit more involved then what we did above. First, it runs the same loop with cross-validation, to find the best parameter combination. Once it has the best combination, it runs fit again on all data passed to fit (without cross-validation), to built a single new model using the best parameter setting. Then, as with all models, we can use predict or score: End of explanation print(grid.best_score_) print(grid.best_params_) Explanation: You can inspect the best parameters found by GridSearchCV in the best_params_ attribute, and the best score in the best_score_ attribute: End of explanation from sklearn.cross_validation import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) param_grid = {'C': [0.001, 0.01, 0.1, 1, 10], 'gamma': [0.001, 0.01, 0.1, 1]} cv = KFold(n=len(X_train), n_folds=10, shuffle=True) grid = GridSearchCV(SVR(), param_grid=param_grid, cv=cv) grid.fit(X_train, y_train) grid.score(X_test, y_test) Explanation: There is a problem with using this score for evaluation, however. You might be making what is called a multiple hypothesis testing error. If you try very many parameter settings, some of them will work better just by chance, and the score that you obtained might not reflect how your model would perform on new unseen data. Therefore, it is good to split off a separate test-set before performing grid-search. This pattern can be seen as a training-validation-test split, and is common in machine learning: We can do this very easily by splitting of some test data using train_test_split, training GridSearchCV on the training set, and applying the score method to the test set: End of explanation from sklearn.cross_validation import train_test_split, ShuffleSplit X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) param_grid = {'C': [0.001, 0.01, 0.1, 1, 10], 'gamma': [0.001, 0.01, 0.1, 1]} single_split_cv = ShuffleSplit(len(X_train), 1) grid = GridSearchCV(SVR(), param_grid=param_grid, cv=single_split_cv, verbose=3) grid.fit(X_train, y_train) grid.score(X_test, y_test) Explanation: Some practitioners go for an easier scheme, splitting the data simply into three parts, training, validation and testing. This is a possible alternative if your training set is very large, or it is infeasible to train many models using cross-validation because training a model takes very long. You can do this with scikit-learn for example by splitting of a test-set and then applying GridSearchCV with ShuffleSplit cross-validation with a single iteration: End of explanation
12,430	Given the following text description, write Python code to implement the functionality described below step by step Description: Title Step1: Create The Data The dataset used in this tutorial is the famous iris dataset. The Iris target data contains 50 samples from three species of Iris, y and four feature variables, X. Step2: View The Data Step3: Split The Data Into Training And Test Sets Step4: Train A Random Forest Classifier Step5: The scores above are the importance scores for each variable. There are two things to note. First, all the importance scores add up to 100%. Second, Petal Length and Petal Width are far more important than the other two features. Combined, Petal Length and Petal Width have an importance of ~0.86! Clearly these are the most importance features. Identify And Select Most Important Features Step6: Create A Data Subset With Only The Most Important Features Step7: Train A New Random Forest Classifier Using Only Most Important Features Step8: Compare The Accuracy Of Our Full Feature Classifier To Our Limited Feature Classifier	Python Code: import numpy as np from sklearn.ensemble import RandomForestClassifier from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.feature_selection import SelectFromModel from sklearn.metrics import accuracy_score Explanation: Title: Feature Selection Using Random Forest Slug: feature_selection_using_random_forest Summary: Feature Selection Using Random Forest with scikit-learn. Date: 2016-12-01 12:00 Category: Machine Learning Tags: Feature Selection Authors: Chris Albon Often in data science we have hundreds or even millions of features and we want a way to create a model that only includes the most important features. This has three benefits. First, we make our model more simple to interpret. Second, we can reduce the variance of the model, and therefore overfitting. Finally, we can reduce the computational cost (and time) of training a model. The process of identifying only the most relevant features is called "feature selection." Random Forests are often used for feature selection in a data science workflow. The reason is because the tree-based strategies used by random forests naturally ranks by how well they improve the purity of the node. This mean decrease in impurity over all trees (called gini impurity). Nodes with the greatest decrease in impurity happen at the start of the trees, while notes with the least decrease in impurity occur at the end of trees. Thus, by pruning trees below a particular node, we can create a subset of the most important features. In this tutorial we will: Prepare the dataset Train a random forest classifier Identify the most important features Create a new 'limited featured' dataset containing only those features Train a second classifier on this new dataset Compare the accuracy of the 'full featured' classifier to the accuracy of the 'limited featured' classifier Note: There are other definitions of importance, however in this tutorial we limit our discussion to gini importance. Preliminaries End of explanation # Load the iris dataset iris = datasets.load_iris() # Create a list of feature names feat_labels = ['Sepal Length','Sepal Width','Petal Length','Petal Width'] # Create X from the features X = iris.data # Create y from output y = iris.target Explanation: Create The Data The dataset used in this tutorial is the famous iris dataset. The Iris target data contains 50 samples from three species of Iris, y and four feature variables, X. End of explanation # View the features X[0:5] # View the target data y Explanation: View The Data End of explanation # Split the data into 40% test and 60% training X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0) Explanation: Split The Data Into Training And Test Sets End of explanation # Create a random forest classifier clf = RandomForestClassifier(n_estimators=10000, random_state=0, n_jobs=-1) # Train the classifier clf.fit(X_train, y_train) # Print the name and gini importance of each feature for feature in zip(feat_labels, clf.feature_importances_): print(feature) Explanation: Train A Random Forest Classifier End of explanation # Create a selector object that will use the random forest classifier to identify # features that have an importance of more than 0.15 sfm = SelectFromModel(clf, threshold=0.15) # Train the selector sfm.fit(X_train, y_train) # Print the names of the most important features for feature_list_index in sfm.get_support(indices=True): print(feat_labels[feature_list_index]) Explanation: The scores above are the importance scores for each variable. There are two things to note. First, all the importance scores add up to 100%. Second, Petal Length and Petal Width are far more important than the other two features. Combined, Petal Length and Petal Width have an importance of ~0.86! Clearly these are the most importance features. Identify And Select Most Important Features End of explanation # Transform the data to create a new dataset containing only the most important features # Note: We have to apply the transform to both the training X and test X data. X_important_train = sfm.transform(X_train) X_important_test = sfm.transform(X_test) Explanation: Create A Data Subset With Only The Most Important Features End of explanation # Create a new random forest classifier for the most important features clf_important = RandomForestClassifier(n_estimators=10000, random_state=0, n_jobs=-1) # Train the new classifier on the new dataset containing the most important features clf_important.fit(X_important_train, y_train) Explanation: Train A New Random Forest Classifier Using Only Most Important Features End of explanation # Apply The Full Featured Classifier To The Test Data y_pred = clf.predict(X_test) # View The Accuracy Of Our Full Feature (4 Features) Model accuracy_score(y_test, y_pred) # Apply The Full Featured Classifier To The Test Data y_important_pred = clf_important.predict(X_important_test) # View The Accuracy Of Our Limited Feature (2 Features) Model accuracy_score(y_test, y_important_pred) Explanation: Compare The Accuracy Of Our Full Feature Classifier To Our Limited Feature Classifier End of explanation
12,431	Given the following text description, write Python code to implement the functionality described below step by step Description: Using Lime with Pytorch In this tutorial we will show how to use Lime framework with Pytorch. Specifically, we will use Lime to explain the prediction generated by one of the pretrained ImageNet models. Let's start with importing our dependencies. This code is tested with Pytorch 1.0 but should work with older versions as well. Step1: Load our test image and see how it looks. Step2: We need to convert this image to Pytorch tensor and also apply whitening as used by our pretrained model. Step3: Load the pretrained model for Resnet50 available in Pytorch. Step4: Load label texts for ImageNet predictions so we know what model is predicting Step5: Get the predicition for our image. Step6: Predicitions we got are logits. Let's pass that through softmax to get probabilities and class labels for top 5 predictions. Step7: We are getting ready to use Lime. Lime produces the array of images from original input image by pertubation algorithm. So we need to provide two things Step8: Now we are ready to define classification function that Lime needs. The input to this function is numpy array of images where each image is ndarray of shape (channel, height, width). The output is numpy aaray of shape (image index, classes) where each value in array should be probability for that image, class combination. Step9: Let's test our function for the sample image. Step10: Import lime and create explanation for this prediciton. Step11: Let's use mask on image and see the areas that are encouraging the top prediction. Step12: Let's turn on areas that contributes against the top prediction.	Python Code: import matplotlib.pyplot as plt from PIL import Image import torch.nn as nn import numpy as np import os, json import torch from torchvision import models, transforms from torch.autograd import Variable import torch.nn.functional as F Explanation: Using Lime with Pytorch In this tutorial we will show how to use Lime framework with Pytorch. Specifically, we will use Lime to explain the prediction generated by one of the pretrained ImageNet models. Let's start with importing our dependencies. This code is tested with Pytorch 1.0 but should work with older versions as well. End of explanation def get_image(path): with open(os.path.abspath(path), 'rb') as f: with Image.open(f) as img: return img.convert('RGB') img = get_image('./data/dogs.png') plt.imshow(img) Explanation: Load our test image and see how it looks. End of explanation # resize and take the center part of image to what our model expects def get_input_transform(): normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transf = transforms.Compose([ transforms.Resize((256, 256)), transforms.CenterCrop(224), transforms.ToTensor(), normalize ]) return transf def get_input_tensors(img): transf = get_input_transform() # unsqeeze converts single image to batch of 1 return transf(img).unsqueeze(0) Explanation: We need to convert this image to Pytorch tensor and also apply whitening as used by our pretrained model. End of explanation model = models.inception_v3(pretrained=True) Explanation: Load the pretrained model for Resnet50 available in Pytorch. End of explanation idx2label, cls2label, cls2idx = [], {}, {} with open(os.path.abspath('./data/imagenet_class_index.json'), 'r') as read_file: class_idx = json.load(read_file) idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))] cls2label = {class_idx[str(k)][0]: class_idx[str(k)][1] for k in range(len(class_idx))} cls2idx = {class_idx[str(k)][0]: k for k in range(len(class_idx))} Explanation: Load label texts for ImageNet predictions so we know what model is predicting End of explanation img_t = get_input_tensors(img) model.eval() logits = model(img_t) Explanation: Get the predicition for our image. End of explanation probs = F.softmax(logits, dim=1) probs5 = probs.topk(5) tuple((p,c, idx2label[c]) for p, c in zip(probs5[0][0].detach().numpy(), probs5[1][0].detach().numpy())) Explanation: Predicitions we got are logits. Let's pass that through softmax to get probabilities and class labels for top 5 predictions. End of explanation def get_pil_transform(): transf = transforms.Compose([ transforms.Resize((256, 256)), transforms.CenterCrop(224) ]) return transf def get_preprocess_transform(): normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transf = transforms.Compose([ transforms.ToTensor(), normalize ]) return transf pill_transf = get_pil_transform() preprocess_transform = get_preprocess_transform() Explanation: We are getting ready to use Lime. Lime produces the array of images from original input image by pertubation algorithm. So we need to provide two things: (1) original image as numpy array (2) classification function that would take array of purturbed images as input and produce the probabilities for each class for each image as output. For Pytorch, first we need to define two separate transforms: (1) to take PIL image, resize and crop it (2) take resized, cropped image and apply whitening. End of explanation def batch_predict(images): model.eval() batch = torch.stack(tuple(preprocess_transform(i) for i in images), dim=0) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) batch = batch.to(device) logits = model(batch) probs = F.softmax(logits, dim=1) return probs.detach().cpu().numpy() Explanation: Now we are ready to define classification function that Lime needs. The input to this function is numpy array of images where each image is ndarray of shape (channel, height, width). The output is numpy aaray of shape (image index, classes) where each value in array should be probability for that image, class combination. End of explanation test_pred = batch_predict([pill_transf(img)]) test_pred.squeeze().argmax() Explanation: Let's test our function for the sample image. End of explanation from lime import lime_image explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(np.array(pill_transf(img)), batch_predict, # classification function top_labels=5, hide_color=0, num_samples=1000) # number of images that will be sent to classification function Explanation: Import lime and create explanation for this prediciton. End of explanation from skimage.segmentation import mark_boundaries temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=False) img_boundry1 = mark_boundaries(temp/255.0, mask) plt.imshow(img_boundry1) Explanation: Let's use mask on image and see the areas that are encouraging the top prediction. End of explanation temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=10, hide_rest=False) img_boundry2 = mark_boundaries(temp/255.0, mask) plt.imshow(img_boundry2) Explanation: Let's turn on areas that contributes against the top prediction. End of explanation
12,432	Given the following text description, write Python code to implement the functionality described below step by step Description: Training a better model Step1: Are we underfitting? Our validation accuracy so far has generally been higher than our training accuracy. That leads to two obvious questions Step2: ...and load our fine-tuned weights. Step3: Split conv and dense layers We're going to be training a number of iterations without dropout, so it would be best for us to pre-calculate the input to the fully connected layers - i.e. the Flatten() layer. We'll start by finding this layer in our model, and creating a new model that contains just the layers up to and including this layer Step4: Generate features for the FC layers by precalculating conv output Now we can use the exact same approach to creating features as we used when we created the linear model from the imagenet predictions in the last lesson - it's only the model that has changed. As you're seeing, there's a fairly small number of "recipes" that can get us a long way! Step5: Below Step6: Remove dropout from the fully-connected layer model For our new fully connected model, we'll create it using the exact same architecture as the last layers of VGG 16, so that we can conveniently copy pre-trained weights over from that model. However, we'll set the dropout layer's p values to zero, so as to effectively remove dropout. Step7: Fit the FC model to the training and validation data And fit the model in the usual way Step8: Save the weights (no dropout) Step9: Reducing overfitting Now that we've gotten the model to overfit, we can take a number of steps to reduce this. Add data augmentation to the training data Let's try adding a small amount of data augmentation, and see if we reduce overfitting as a result. The approach will be identical to the method we used to finetune the dense layers in lesson 2, except that we will use a generator with augmentation configured. Here's how we set up the generator, and create batches from it Step10: Combine the Conv and FC layers into a single model When using data augmentation, we can't pre-compute our convolutional layer features, since randomized changes are being made to every input image. That is, even if the training process sees the same image multiple times, each time it will have undergone different data augmentation, so the results of the convolutional layers will be different. Therefore, in order to allow data to flow through all the conv layers and our new dense layers, we attach our fully connected model to the convolutional model--after ensuring that the convolutional layers are not trainable Step11: Now we can compile, train, and save our model as usual - note that we use fit_generator() since we want to pull random images from the directories on every batch. Compile and train the combined model on augmented data Step12: Save the weights (combined) Step13: Add batchnorm to the model We can use nearly the same approach as before - but this time we'll add batchnorm layers (and dropout layers) Step14: Create a standalone model from the BN layers of vgg16bn Step15: Compile and fit the model Step16: Save the weights (batchnorm) Step17: Create another BN model and combine it with the conv layers into a final model Step18: Set the BN layers weights from the first BN model Step19: Fit the model Step20: Save the weights (final model) Step21: Fit the model Step22: Save the weights (final model) Step23: Fit the model Step24: Save the weights (final model)	Python Code: from theano.sandbox import cuda %matplotlib inline import utils; reload(utils) from utils import * from __future__ import division, print_function #path = os.path.join('input','sample') path = os.path.join('input','sample-10') #path = os.path.join('input') output_path = os.path.join('output','sample') model_path = os.path.join(output_path, 'models') if not os.path.exists(model_path): os.mkdir(model_path) #batch_size=64 #batch_size=32 #batch_size=16 batch_size=8 Explanation: Training a better model End of explanation model = vgg_ft(2) ??vgg_ft Explanation: Are we underfitting? Our validation accuracy so far has generally been higher than our training accuracy. That leads to two obvious questions: How is this possible? Is this desirable? The answer to (1) is that this is happening because of dropout. Dropout refers to a layer that randomly deletes (i.e. sets to zero) each activation in the previous layer with probability p (generally 0.5). This only happens during training, not when calculating the accuracy on the validation set, which is why the validation set can show higher accuracy than the training set. The purpose of dropout is to avoid overfitting. By deleting parts of the neural network at random during training, it ensures that no one part of the network can overfit to one part of the training set. The creation of dropout was one of the key developments in deep learning, and has allowed us to create rich models without overfitting. However, it can also result in underfitting if overused, and this is something we should be careful of with our model. So the answer to (2) is: this is probably not desirable. It is likely that we can get better validation set results with less (or no) dropout, if we're seeing that validation accuracy is higher than training accuracy - a strong sign of underfitting. So let's try removing dropout entirely, and see what happens! (We had dropout in this model already because the VGG authors found it necessary for the imagenet competition. But that doesn't mean it's necessary for dogs v cats, so we will do our own analysis of regularization approaches from scratch.) Removing dropout Our high level approach here will be to start with our fine-tuned cats vs dogs model (with dropout), then fine-tune all the dense layers, after removing dropout from them. The steps we will take are: - Re-create and load our modified VGG model with binary dependent (i.e. dogs v cats) - Split the model between the convolutional (conv) layers and the dense layers - Pre-calculate the output of the conv layers, so that we don't have to redundently re-calculate them on every epoch - Create a new model with just the dense layers, and dropout p set to zero - Train this new model using the output of the conv layers as training data. Start with Vgg + binary output (dogs/cats) As before we need to start with a working model, so let's bring in our working VGG 16 model and change it to predict our binary dependent... End of explanation #model.load_weights(model_path+'finetune3.h5') model.load_weights(os.path.join(model_path, 'finetune_1_ll.h5')) Explanation: ...and load our fine-tuned weights. End of explanation layers = model.layers last_conv_idx = [index for index,layer in enumerate(layers) if type(layer) is Convolution2D][-1] last_conv_idx layers[last_conv_idx] conv_layers = layers[:last_conv_idx+1] # convolutional layers only; i.e. first N layers to the index conv_model = Sequential(conv_layers) # Dense layers - also known as fully connected or 'FC' layers fc_layers = layers[last_conv_idx+1:] # remaining layers are Dense/FC Explanation: Split conv and dense layers We're going to be training a number of iterations without dropout, so it would be best for us to pre-calculate the input to the fully connected layers - i.e. the Flatten() layer. We'll start by finding this layer in our model, and creating a new model that contains just the layers up to and including this layer: End of explanation batches = get_batches(os.path.join(path,'train'), shuffle=False, batch_size=batch_size) val_batches = get_batches(os.path.join(path,'valid'), shuffle=False, batch_size=batch_size) val_classes = val_batches.classes trn_classes = batches.classes val_labels = onehot(val_classes) trn_labels = onehot(trn_classes) Explanation: Generate features for the FC layers by precalculating conv output Now we can use the exact same approach to creating features as we used when we created the linear model from the imagenet predictions in the last lesson - it's only the model that has changed. As you're seeing, there's a fairly small number of "recipes" that can get us a long way! End of explanation val_features = conv_model.predict_generator(val_batches, val_batches.nb_sample) trn_features = conv_model.predict_generator(batches, batches.nb_sample) save_array(os.path.join(model_path, 'train_convlayer_features.bc'), trn_features) save_array(os.path.join(model_path,'valid_convlayer_features.bc'), val_features) ??save_array trn_features = load_array(os.path.join(model_path, 'train_convlayer_features.bc')) val_features = load_array(os.path.join(model_path,'valid_convlayer_features.bc')) trn_features.shape val_features.shape Explanation: Below: We're pre-calculating the inputs to the new model. The inputs are the training and valiation sets. So, we basically want to get the result of running those two sets thru the conv layers only and save them so we can run them through the new model. So, we use the conv-only model to run prediction on the training and validation sets in order to precompute the values we need. End of explanation # Copy the weights from the pre-trained model. # NB: Since we're removing dropout, we want to half the weights def proc_wgts(layer): return [o/2 for o in layer.get_weights()] # Such a finely tuned model needs to be updated very slowly! opt = RMSprop(lr=0.00001, rho=0.7) def get_fc_model(): model = Sequential([ MaxPooling2D(input_shape=conv_layers[-1].output_shape[1:]), Flatten(), Dense(4096, activation='relu'), Dropout(0.), Dense(4096, activation='relu'), Dropout(0.), Dense(2, activation='softmax') ]) for l1,l2 in zip(model.layers, fc_layers): l1.set_weights(proc_wgts(l2)) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) return model fc_model = get_fc_model() Explanation: Remove dropout from the fully-connected layer model For our new fully connected model, we'll create it using the exact same architecture as the last layers of VGG 16, so that we can conveniently copy pre-trained weights over from that model. However, we'll set the dropout layer's p values to zero, so as to effectively remove dropout. End of explanation fc_model.fit(trn_features, trn_labels, nb_epoch=8, batch_size=batch_size, validation_data=(val_features, val_labels)) ??fc_model.fit Explanation: Fit the FC model to the training and validation data And fit the model in the usual way: End of explanation fc_model.save_weights(os.path.join(model_path,'lesson3_no_dropout.h5')) fc_model.load_weights(os.path.join(model_path,'lesson3_no_dropout.h5')) Explanation: Save the weights (no dropout) End of explanation gen = image.ImageDataGenerator(rotation_range=15, width_shift_range=0.1, height_shift_range=0.1, zoom_range=0.1, horizontal_flip=True) batches = get_batches(os.path.join(path, 'train'), gen, batch_size=batch_size) # NB: We don't want to augment or shuffle the validation set val_batches = get_batches(os.path.join(path, 'valid'), shuffle=False, batch_size=batch_size) Explanation: Reducing overfitting Now that we've gotten the model to overfit, we can take a number of steps to reduce this. Add data augmentation to the training data Let's try adding a small amount of data augmentation, and see if we reduce overfitting as a result. The approach will be identical to the method we used to finetune the dense layers in lesson 2, except that we will use a generator with augmentation configured. Here's how we set up the generator, and create batches from it: End of explanation fc_model = get_fc_model() for layer in conv_model.layers: layer.trainable = False # Look how easy it is to connect two models together! conv_model.add(fc_model) Explanation: Combine the Conv and FC layers into a single model When using data augmentation, we can't pre-compute our convolutional layer features, since randomized changes are being made to every input image. That is, even if the training process sees the same image multiple times, each time it will have undergone different data augmentation, so the results of the convolutional layers will be different. Therefore, in order to allow data to flow through all the conv layers and our new dense layers, we attach our fully connected model to the convolutional model--after ensuring that the convolutional layers are not trainable: End of explanation conv_model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) conv_model.fit_generator(batches, samples_per_epoch=batches.nb_sample, nb_epoch=8, validation_data=val_batches, nb_val_samples=val_batches.nb_sample) Explanation: Now we can compile, train, and save our model as usual - note that we use fit_generator() since we want to pull random images from the directories on every batch. Compile and train the combined model on augmented data End of explanation conv_model.save_weights(os.path.join(model_path, 'aug1.h5')) conv_model.load_weights(os.path.join(model_path, 'aug1.h5')) Explanation: Save the weights (combined) End of explanation conv_layers[-1].output_shape[1:] # last layer shape def get_bn_layers(p): return [ MaxPooling2D(input_shape=conv_layers[-1].output_shape[1:]), Flatten(), Dense(4096, activation='relu'), BatchNormalization(), Dropout(p), Dense(4096, activation='relu'), BatchNormalization(), Dropout(p), Dense(1000, activation='softmax') ] def load_fc_weights_from_vgg16bn(model): "Load weights for model from the dense layers of the Vgg16BN model." # See imagenet_batchnorm.ipynb for info on how the weights for # Vgg16BN can be generated from the standard Vgg16 weights. from vgg16bn import Vgg16BN vgg16_bn = Vgg16BN() _, fc_layers = split_at(vgg16_bn.model, Convolution2D) copy_weights(fc_layers, model.layers) p=0.6 Explanation: Add batchnorm to the model We can use nearly the same approach as before - but this time we'll add batchnorm layers (and dropout layers): End of explanation #bn_model = Sequential(get_bn_layers(0.6)) bn_model = Sequential(get_bn_layers(p)) load_fc_weights_from_vgg16bn(bn_model) def proc_wgts(layer, prev_p, new_p): scal = (1-prev_p)/(1-new_p) return [o*scal for o in layer.get_weights()] for l in bn_model.layers: if type(l)==Dense: l.set_weights(proc_wgts(l, 0.5, 0.6)) # here l == 'l' not '1' # Remove last layer and lock all the others bn_model.pop() for layer in bn_model.layers: layer.trainable=False # Add linear layer (2-class) (just doing the ImageNet mapping to Kaggle dogs and cats) bn_model.add(Dense(2,activation='softmax')) Explanation: Create a standalone model from the BN layers of vgg16bn End of explanation bn_model.compile(Adam(), 'categorical_crossentropy', metrics=['accuracy']) bn_model.fit(trn_features, trn_labels, nb_epoch=8, validation_data=(val_features, val_labels)) Explanation: Compile and fit the model End of explanation bn_model.save_weights(os.path.join(model_path,'bn.h5')) bn_model.load_weights(os.path.join(model_path,'bn.h5')) Explanation: Save the weights (batchnorm) End of explanation bn_layers = get_bn_layers(0.6) bn_layers.pop() bn_layers.append(Dense(2,activation='softmax')) final_model = Sequential(conv_layers) for layer in final_model.layers: layer.trainable = False for layer in bn_layers: final_model.add(layer) Explanation: Create another BN model and combine it with the conv layers into a final model End of explanation for l1,l2 in zip(bn_model.layers, bn_layers): l2.set_weights(l1.get_weights()) Explanation: Set the BN layers weights from the first BN model End of explanation final_model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy']) final_model.fit_generator(batches, samples_per_epoch=batches.nb_sample, nb_epoch=1, validation_data=val_batches, nb_val_samples=val_batches.nb_sample) Explanation: Fit the model End of explanation final_model.save_weights(os.path.join(model_path, 'final1.h5')) Explanation: Save the weights (final model) End of explanation final_model.fit_generator(batches, samples_per_epoch=batches.nb_sample, nb_epoch=4, validation_data=val_batches, nb_val_samples=val_batches.nb_sample) Explanation: Fit the model End of explanation final_model.save_weights(os.path.join(model_path, 'final2.h5')) final_model.optimizer.lr=0.001 Explanation: Save the weights (final model) End of explanation final_model.fit_generator(batches, samples_per_epoch=batches.nb_sample, nb_epoch=4, validation_data=val_batches, nb_val_samples=val_batches.nb_sample) Explanation: Fit the model End of explanation bn_model.save_weights(os.path.join(model_path, 'final3.h5')) Explanation: Save the weights (final model) End of explanation
12,433	Given the following text description, write Python code to implement the functionality described below step by step Description: NormMUSIC Demo The goal of this notebook is to demonstrate the effect of frequency normalization when MUSIC is applied on broadband signals The notebook is structured as follows Step1: <a id='dataset'></a> Dataset generation In the following, we simulate a small dataset to evaluate the performance of MUSIC and NormMUSIC. We assume a single sound source. - Simulate different rooms Step2: <a id='prediction'></a> Prediction In the following, we apply MUSIC and NormMUSIC to the simulated dataset. The results are stored in a pandas DataFrame Step3: <a id='evaluation'></a> Evaluation In the next cells we calculate the following metrics Step4: <a id='intuition'></a> Intuition Step5: In the next cell, we calculate the maxima of the individual MUSIC pseudp-spectra per frequency bin $k$, i.e., $$ \hat{\theta}k = max\theta \;\hat{P}_{MUSIC}(\theta, k)$$ and visualize them in a swarm plot. From the plot, it should be clear that effectively only a few frequency bins contribute to the solution (if no normalization is applied).	Python Code: # imports import pickle import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from scipy.signal import stft from random import uniform, sample from pyroomacoustics import doa, Room, ShoeBox Explanation: NormMUSIC Demo The goal of this notebook is to demonstrate the effect of frequency normalization when MUSIC is applied on broadband signals The notebook is structured as follows: 1. Dataset generation 2. Prediction <ol> <li>MUSIC: Standard implementation without normalization</li> <li>NormMUSIC: Implementation with frequency normalization as suggested in [1]</li> </ol> 3. Evaluation 4. Intuition: Why normalization? 4. Recommendation [1] D. Salvati, C. Drioli and G. L. Foresti, "Incoherent Frequency Fusion for Broadband Steered Response Power Algorithms in Noisy Environments," in IEEE Signal Processing Letters, vol. 21, no. 5, pp. 581-585, 2014. End of explanation # constants / config fs = 16000 nfft = 1024 n = 5fs # simulation length of source signal (3 seconds) n_frames = 30 max_order = 10 doas_deg = np.linspace(start=0, stop=359, num=360, endpoint=True) rs = [0.5, 1, 1.5] mic_center = np.c_[[2,2,1]] mic_locs = mic_center + np.c_[[ 0.04, 0.0, 0.0], [ 0.0, 0.04, 0.0], [-0.04, 0.0, 0.0], [ 0.0, -0.04, 0.0], ] snr_lb, snr_ub = 0, 30 # room simulation data = [] for r in rs: for i, doa_deg in enumerate(doas_deg): doa_rad = np.deg2rad(doa_deg) source_loc = mic_center[:,0] + np.c_[rnp.cos(doa_rad), rnp.sin(doa_rad), 0][0] room_dim = [uniform(4,6), uniform(4,6), uniform(2, 4)] # meters room = ShoeBox(room_dim, fs=fs, max_order=max_order) room.add_source(source_loc, signal=np.random.random(n)) room.add_microphone_array(mic_locs) room.simulate(snr=uniform(snr_lb, snr_ub)) signals = room.mic_array.signals # calculate n_frames stft frames starting at 1 second stft_signals = stft(signals[:,fs:fs+n_framesnfft], fs=fs, nperseg=nfft, noverlap=0, boundary=None)[2] data.append([r, doa_deg, stft_signals]) Explanation: <a id='dataset'></a> Dataset generation In the following, we simulate a small dataset to evaluate the performance of MUSIC and NormMUSIC. We assume a single sound source. - Simulate different rooms: - DOA on 1° grid - 3 samples per DOA - Source signal: Random Gaussian - Different SNRs between 0 and 30 dB - Calculate 30 STFT time frames for each sample End of explanation kwargs = {'L': mic_locs, 'fs': fs, 'nfft': nfft, 'azimuth': np.deg2rad(np.arange(360)) } algorithms = { 'MUSIC': doa.music.MUSIC(kwargs), 'NormMUSIC': doa.normmusic.NormMUSIC(kwargs), } columns = ["r", "DOA"] + list(algorithms.keys()) predictions = {n:[] for n in columns} for r, doa_deg, stft_signals in data: predictions['r'].append(r) predictions['DOA'].append(doa_deg) for algo_name, algo in algorithms.items(): algo.locate_sources(stft_signals) predictions[algo_name].append(np.rad2deg(algo.azimuth_recon[0])) df = pd.DataFrame.from_dict(predictions) Explanation: <a id='prediction'></a> Prediction In the following, we apply MUSIC and NormMUSIC to the simulated dataset. The results are stored in a pandas DataFrame End of explanation MAE, MEDAE = {}, {} def calc_ae(a,b): x = np.abs(a-b) return np.min(np.array((x, np.abs(360-x))), axis=0) for algo_name in algorithms.keys(): ae = calc_ae(df.loc[:,["DOA"]].to_numpy(), df.loc[:,[algo_name]].to_numpy()) MAE[algo_name] = np.mean(ae) MEDAE[algo_name] = np.median(ae) print(f"MAE\t MUSIC: {MAE['MUSIC']:5.2f}\t NormMUSIC: {MAE['NormMUSIC']:5.2f}") print(f"MEDAE\t MUSIC: {MEDAE['MUSIC']:5.2f}\t NormMUSIC: {MEDAE['NormMUSIC']:5.2f}") Explanation: <a id='evaluation'></a> Evaluation In the next cells we calculate the following metrics: - Mean Absolute Error (MAE) - Median Absolute error (MEDAE) End of explanation fig = plt.figure(figsize=(14,10)) frequencies = sample(list(range(algorithms['MUSIC'].Pssl.shape[1])), k=10) for i, k in enumerate(frequencies): plt.plot(algorithms["MUSIC"].Pssl[:,k]) plt.xlabel("angle [°]") plt.title("Multiple narrowband MUSIC pseudo spectra in one plot", fontsize=15) Explanation: <a id='intuition'></a> Intuition: Why normalization? MUSIC revisited: Complex narrowband signals Before we discuss the intution behind frequency normalization, let's revisit the MUSIC algorithm for complex narrowband signals. The MUSIC pseudo spectrum The MUSIC pseudo spectrum $\hat{P}_{MUSIC}(\theta)$ is defined as: $$\hat{P}{MUSIC}(\mathbf{e}(\theta)) = \frac{1}{\sum{i=p+1}^{N} \|\mathbf{e}(\theta)^H \mathbf{v}_i\|}$$, where - $\mathbf{v}_i$ are the noise eigenvectors - $\mathbf{e}(\theta)$ is the candidate steering vector - $\theta$ is the candidate DOA MUSIC obtains its estimated DOA $\hat{\theta}$ by maximizing the pseudo spectrum $\hat{P}{MUSIC}(\theta)$ over the candidate DOAs $\theta \in {\theta_1, \theta_2, ... \theta_I}$, i.e., $$\hat{\theta} = {arg max}\theta \;\hat{P}_{MUSIC}(\theta)$$ Orthogonality The main property that is exploited by MUSIC is the orthogonality between the noise eigenvectors $\mathbf{v}i$ and the steering vector $\mathbf{e}(\theta^{\star})$ of the DOA $\theta^{\star}$, i.e., $$ \mathbf{e}(\theta^{\star}) \perp span(\mathbf{v}{p+1}, \mathbf{v}{p+2}, \mathbf{v}{N}) \;\; \Leftrightarrow \;\; \|\mathbf{e}(\theta^{\star})^H \mathbf{v}_i\| = 0 \;\; \forall i \in {p+1, p+2, ... N}$$ In practice, $\hat{\theta}$ is approximately orthogonal to the noise eigenvectors $\mathbf{v}_i$, i.e., $$ \|\mathbf{e}(\hat{\theta})^H \mathbf{v}_i\| \approx 0 \;\; \forall i \in {p+1, p+2, ... N}$$ Therefore, ${max}{\theta} \; \hat{P}{MUSIC}(\theta) = \frac{1}{\epsilon}$, with $\epsilon \ll 1$, which results in a curve with (one of more) distict peak(s) that is characteristic for the MUSIC pseudo spectrum. An example of a MUSIC pseudo spectrum is plotted below: MUSIC revisited: STFT processing for broadband signals When MUSIC is applied to broadband signals via STFT-processing, a pseudo spectrum $\hat{P}_{MUSIC}(\theta, k)$ is calculated for each individual frequency bin $k$. The individual MUSIC pseudo spectra $\hat{P}_{MUSIC}(\theta, k)$ are summed across all frequency bins $k \in {1, 2, \ldots, K}$. In the simplest case, this is performed without normalization, i.e., $$\tilde{P}{MUSIC}(\theta) = \sum{k=1}^{K} \hat{P}_{MUSIC}(\theta, k)$$ While this is the commonly used implementation, it is far from being optimal, since the maxima of the MUSIC pseudospectra $\hat{P}_{MUSIC}(\theta, k)$ may differ in orders of magnitude. By summing across frequencies without normalization, only the information of the few frequencies with the highest peaks in the MUSIC pseudo spectra are used. The information of frequencies with lower peaks in the MUSIC pseudo spectra are practically not used to estimate the DOA. To illustrate this, let's first plot the MUSIC pseudo spectra of 10 randomly selected frequency bins. End of explanation # calculation maxima = sorted(np.max(algorithms["MUSIC"].Pssl, axis=0)) #plotting fig, ax = plt.subplots(1, 1, figsize=(14,10)) sns.swarmplot(data=maxima, ax=ax, size=6) ax.set_title("\nDistribution: Maxima of the MUSIC pseudo spectra of multiple frequency bins\n", fontsize=20) ax.set_xticks([1]) Explanation: In the next cell, we calculate the maxima of the individual MUSIC pseudp-spectra per frequency bin $k$, i.e., $$ \hat{\theta}k = max\theta \;\hat{P}_{MUSIC}(\theta, k)$$ and visualize them in a swarm plot. From the plot, it should be clear that effectively only a few frequency bins contribute to the solution (if no normalization is applied). End of explanation
12,434	Given the following text description, write Python code to implement the functionality described below step by step Description: Overview Contents Introduction to Python The Python Interpreter First Steps with Python Importing Libraries About the Data Arrays and their Attributes Getting Help More on Arrays Basic Data Visualization Repeating Tasks with Loops Sequences More Complex Loops Iterators and Generators Analyzing Data from Multiple Files Looping over Files Generating a Plot Putting it All Together Conditional Evaluation Conditional Expressions in Python Checking our Data Creating Functions for Reuse Composing Multiple Functions Cleaning Up our Analysis Code Positional versus Keyword Arguments Documenting Functions Capstone Step1: Python at the Command Line We've seen a lot of tools and techniques for improving our productivity through reproducible Python code. So far, however, we've been working exclusively within Jupyter Notebook. Jupyter Notebook is great for interactive, exploratory work in Python and encourages literate programming, as we discussed earlier. A Notebook is a great place to demonstrate to your future self or your peers how some Python code works. But when it's time to scale-up your work and process data, you want to be on the command line, for all the reasons we saw when we discussed the Unix shell earlier. Let's explore Python programs at the command line using the following Python script, temp_extremes.py. ```py ''' Reports the min and max July temperatures for each file that matches the given filename pattern. ''' import csv import os import sys import glob def main() Step2: Assertions Regarding Inherited Type (Advanced) What if we used OrderedDict to represent our metadata? Duck Typing (Advanced) For more information about types, classes, and how Python represents objects, see Step3: When in Doubt... Testing for Quality Control Unit Testing Analyzing and Optimizing Performance "Premature optimization is the root of all evil." - Sir Tony Hoare (later popularized by Donald Knuth) Benchmarking Line and Memory Profiling Line and memory profilers aren't available in the Anaconda installation I had you use, but you can read all about this topic on this excellent blog post. Capstone Now you have a chance to bring together everything you've learned in this Software Carpentry workshop, particularly Step4: Hint Step5: The range() function in Python returns a list of consecutive integers between the first and the second number. The np.in1d function tests each element of our "hour" column to see if it is in the list of numbers from 7 to 18, inclusive. Step6: To filter the full NumPy array to just those rows where the "hour" is between 7 and 18 (inclusive), we can take this vector of True and False values and put inside brackets, as below. Remember that the three dots (...) just mean "everything else" or, more specifically, "all the columns." Step7: Hint Step8: For another way to get all the records associated with a single day, remember that every day has the same number of records. Now that we've filtered to just the daytime records, there should be 36 records per day. Step9: We can slice the first 36 rows of our data table to obtain the first day. The second day would then be rows 37 through 72, and so on. Step10: Connecting to SQLite with Python	Python Code: import glob filenames = glob.glob('.csv') filenames Explanation: Overview Contents Introduction to Python The Python Interpreter First Steps with Python Importing Libraries About the Data Arrays and their Attributes Getting Help More on Arrays Basic Data Visualization Repeating Tasks with Loops Sequences More Complex Loops Iterators and Generators Analyzing Data from Multiple Files Looping over Files Generating a Plot Putting it All Together Conditional Evaluation Conditional Expressions in Python Checking our Data Creating Functions for Reuse Composing Multiple Functions Cleaning Up our Analysis Code Positional versus Keyword Arguments Documenting Functions Capstone: Fitting Linear Models About the Data Introducing statsmodels Python at the Command Line Our First Python Script Alternative Command-Line Tools Modularization Understanding and Handling Errors Defensive Programming Assertions Test-Driven Development Testing for Quality Control Unit Testing Analyzing and Optimizing Performance Benchmarking Capstone Your Tasks Getting Started Connecting to SQLite with Python Introduction to Python The Python Interpreter Jupyter Notebook First Steps with Python Importing Libraries About the Data The data are formatted such that: Each column is the monthly mean, January (1) through December (12) Each row is a year, starting from January 1948 (1) through December 2016 (69) More information on the data can be found here. Arrays and their Attributes How many rows and columns are there in the barrow array? Challenge What do each of the following code samples do? py barrow[0] barrow[0,] barrow[-1] barrow[-3:-1] Slicing NumPy Arrays Challenge What's the mean monthly temperature in August of 2016? Converted to degrees Fahrenheit? Degrees F can be calculated from degrees K by the formula: $$ T_F = \left(T_K \times \frac{9}{5}\right) - 459.67 $$ Calculating on NumPy Arrays What is the overall mean temperature in any month in Barrow between 1948 and 2016 in degrees C? How cold was the coldest February in Barrow, by monthly mean temperatures, in degrees C? Challenge What's the minimum, maximum, and mean monthly temperature for August in Barrow, in degrees C? Getting Help More on Arrays What is the mean temperature in 1948? In 1949? And so on... Remembering the difference between axis = 0 and axis = 1 is tricky, even for experienced Python programmers. Here are some helpful, visual reminders: Integrating across rows or columns (StackOverflow) Another way of visualizing the same thing (Site44) Basic Data Visualization Repeating Tasks with Loops Sequences Character Strings Lists and Tuples Performing Calculations with Lists More Complex Loops Challenge: Looping over Sequences Write a for loop that iterates through the letters of your favorite city, putting each letter inside a list. The result should be a list with an element for each letter. Hint: You can create an empty list like this: py letters = [] Hint: You can confirm you have the right result by comparing it to: py list("my favorite city") Challenge: Sequences and Mutability Which of the sequences we've learned about are immutable (i.e., they can't be changed)? Strings are (immutable / mutable)? Lists are (immutable / mutable)? Tuples are (immutable / mutable)? And what does this mean for working with each data type? ```py "birds".upper() [1, 2, 3].append(4) (1, 2, 3) ``` Iterators and Generators Analyzing Data from Multiple Files First Step: Looping over Files Second Step: Generating a Plot Third Step: Putting It All Together Challenge: Integrating over Multiple File Datasets For each location (each file), plot the difference between that location's mean temperature and the mean across all locations. Hint: One way to calculate the mean across five (5) files is by adding the 5 arrays together, then dividing by 5. You can add arrays together in a loop like this: ```py Start with an array full of zeros that is 69-elements long running_total = np.zeros((69)) for fname in filenames: data = np.loadtxt(fname, delimiter = ',') running_total = running_total + data.mean(axis = 1) ``` Hint: How do you difference two arrays? Remember how the plus, +, and minus, -, operators work on arrays? Conditional Evaluation This code can be represented by the following workflow. Challenge: Conditional Expressions How can you make this code print "Greater" by changing only one line? ```py a_number = 42 if a_number > 100: print('Greater') else: print('Not greater') print('Done') ``` There are two (2) one-line changes you could make. Can you find them both? Conditional Expressions in Python What do each of the following evaluate to, True or False? py 1 < 2 1 <= 1 3 == 3 2 != 3 Checking our Data Challenge: Fitting a Line over Multiple File Datasets Write a for loop, with an if statement inside, that calculates a line of best fit for each dataset's temperature anomalies and prints out a message as to whether that trend line is positive or negative. Hint: What we want to know about each trend line is whether, for: py results = sm.OLS(y_data, x_data).fit() b0, b1 = results.params If b1, the slope of the line, is positive or negative. Creating Functions for Reuse What happens if we remove the keyword return from this function? Make this change and call the function again. Composing Multiple Functions Now that we've created a function that converts temperatures in degrees Kelvin to degrees Celsius, let's see if we can write a function that converts from degrees Celsius to degrees Fahrenheit. $$ T_F = \left(T_C \times \frac{9}{5}\right) + 32 $$ Cleaning Up our Analysis Code Positional versus Keyword Arguments Documenting Functions Challenge: Functions Create one (or both, for an extra challenge) of the following functions... A function called fences that takes an input character string and surrounds it on both sides with another string, e.g., "pasture" becomes "\|pasture\|" or "@pasture@" if either "\|" or "@" are provided. A function called rescale that takes an array and returns a corresponding array of values scaled to lie in the range 0.0 to 1.0. Hint: Strings can be concatenated with the plus operator. py 'cat' + 's' Hint: If $x_0$ and $x_1$ are the lowest and highest values in an array, respectively, then the replacement value for any element $x$, scaled to between 0.0 and 1.0, should be: $$ \frac{x - x_0}{x_1 - x_0} $$ Capstone: Fitting Linear Models We've seen the basics of the Python programming language. Now, let's get some hands-on experience applying what we've learned to real scientific data. In this exercise, we'll see how to fit linear trends to data using a new Python library, statsmodels. After you see an initial example, you'll have time to extend the example on your own. About the Data The data are formatted such that: Each column is the monthly mean, January (1) through December (12) Each row is a year, starting from January 1948 (1) through December 2016 (69) More information on the data can be found here. Introducing statsmodels Without going into too much detail, our linear trend line has two components: a constant term ($\alpha$) and the slope of the trend line ($\beta$). Using linear algebra, we represent these two terms as two columns in a matrix. To fit a linear model with a constant term, the first column is a column of ones. $$ \begin{align} [\mathrm{Temp.\ anomaly}]&=[\mathrm{Some\ constant,\ }\alpha] + [\mathrm{Slope\ of\ trend\ line},\beta]\times[\mathrm{Year}]\ \left[\begin{array}{r} -2.04\ -0.20\ 0.88\ \vdots\ \end{array}\right] &= \left[\begin{array}{rr} 1 & 1948\ 1 & 1949\ 1 & 1950\ \vdots & \vdots\ \end{array}\right] \left[\begin{array}{r} \alpha\ \beta\end{array}\right] \end{align} $$ Challenge: Fitting a Line over Multiple Datasets Write a for loop, with an if statement inside, that calculates a line of best fit for each dataset's temperature anomalies and prints out a message as to whether that trend line is positive or negative. Hint: What we want to know about each trend line is whether, for: py results = sm.OLS(y_data, x_data).fit() b0, b1 = results.params If b1, the slope of the line, is positive or negative. So, to break that down: Loop over all the temperature files; Calculate the temperature anomaly; Fit an OLS regression to the anomaly data; print() out whether the trend line is "positive" or "negative;" Hint: Looping over Files End of explanation def celsius_to_fahr(temp_c): return (temp_c (9/5)) + 32 Explanation: Python at the Command Line We've seen a lot of tools and techniques for improving our productivity through reproducible Python code. So far, however, we've been working exclusively within Jupyter Notebook. Jupyter Notebook is great for interactive, exploratory work in Python and encourages literate programming, as we discussed earlier. A Notebook is a great place to demonstrate to your future self or your peers how some Python code works. But when it's time to scale-up your work and process data, you want to be on the command line, for all the reasons we saw when we discussed the Unix shell earlier. Let's explore Python programs at the command line using the following Python script, temp_extremes.py. ```py ''' Reports the min and max July temperatures for each file that matches the given filename pattern. ''' import csv import os import sys import glob def main(): # Get the user-specified directory directory = sys.argv[1] # Pattern to use in searching for files filename_pattern = os.path.join(directory, '*temperature.csv') for filename in glob.glob(filename_pattern): july_temps = [] # While the file is open... with open(filename, 'r') as stream: # Use a function to read the file reader = csv.reader(stream) # Each row is a year for row in reader: # Add this year's July temperature to the list july_temps.append(row[6]) # A human-readable name for the file pretty_name = os.path.basename(filename) print(pretty_name, '--Hottest July mean temp. was', max(july_temps), 'deg K') print(pretty_name, '--Coolest July mean temp. was', min(july_temps), 'deg K') if name == 'main': main() ``` We can run this script on the command line by typing the following: sh $ python3 temp_extremes.py . Remember that the single dot, . represents the current working directory, which is where all of our temperature CSV files are located. Our First Python Script Encapsulating to Keep the Namespace Clean Alternative Command-Line Tools sys.argv is a rather crude tool for processing command-line arguments. There are a couple of alternatives I suggest you look into if you are going to be writing command-line programs in Python: argparse, another built-in library, that handles common cases in a systematic way. Check out this tutorial. Fire, a very new Python module from Google, which can turn any Python object (function, class, etc.) into a command-line API. Optional: Try out Python Fire Installation instructions and source code here. Modularization Installing Your Project as a Module We haven't covered installing new Python modules, but when the time is right for you to package your code together as a single module (e.g., as package_name, in the example above), consider installing your module "in development mode" first. Understanding and Handling Errors Defensive Programming Assertions Assertations Regarding Type (Advanced) Challenge: Asserting Type in a Function Recall the celsius_to_fahr() function we saw earlier. Implement a type-checking assertion that produces an AssertionError when the temp_c argument is not a number. Remember that there are two types of numbers we've see in Python so far: float int You can decide whether the celsius_to_fahr() function should accept one or both of these types as inputs. Don't forget to provide a helpful message as part of the AssertionError. End of explanation def range_overlap(ranges): '''Return common overlap among a set of [low, high] ranges.''' for i, (low, high) in enumerate(ranges): if i == 0: lowest, highest = low, high continue lowest = max(lowest, low) highest = min(highest, high) if lowest >= highest: return None return (lowest, highest) test_range_overlap() Explanation: Assertions Regarding Inherited Type (Advanced) What if we used OrderedDict to represent our metadata? Duck Typing (Advanced) For more information about types, classes, and how Python represents objects, see: Python 3 Documentation: The Python Data Model Test-Driven Development For example, suppose we need to find where two or more time series overlap. The range of each time series is represented as a pair of numbers, which are the time the interval started and ended. The output is the largest range that they all include. Challenge: Fix the Range Overlap Function Fix range_overlap(); re-run test_range_overlap() after each change you make. End of explanation import numpy as np data = np.loadtxt('/home/arthur/Desktop/ocean.txt', delimiter = ' ') # How many rows and columns? data.shape Explanation: When in Doubt... Testing for Quality Control Unit Testing Analyzing and Optimizing Performance "Premature optimization is the root of all evil." - Sir Tony Hoare (later popularized by Donald Knuth) Benchmarking Line and Memory Profiling Line and memory profilers aren't available in the Anaconda installation I had you use, but you can read all about this topic on this excellent blog post. Capstone Now you have a chance to bring together everything you've learned in this Software Carpentry workshop, particularly: Using the Unix shell to download and manage delimited text data files; Importing data into Python; Using NumPy or other Python tools to summarize the data and diagnose any data issues; Cleaning and plotting the data using reproducible Python functions; For this open-ended exercise, we'll use data from the Woods Hole Oceanographic Institution's "Martha's Vineyard Coastal Observatory." Choose which of the following datasets you want to work with: The meteorological record, which includes solar irradiance (solar_campmt_m50[W/m^2]) and rainfall (rain_campmt[mm]); the order of the fields in the delimited files is listed here. The oceanographic record, which includes wave period and direction, ocean bottom temperature, and many other variables. Each of these data sources has an online file directory: Directory to download meteorological records Directory to download oceanographic records Once you've decided which dataset you want to work with, follow along with me using that particular record. I'm going to use the oceanographic data in this example. Your Tasks Download 3 days worth of meteorological or oceanographic data files using wget or curl in the Unix shell. Join the files together as one file using cat in the Unix shell. Read the data into a Python session. Create a time plot of a variable of your choice. Filter the rows of the table to only daytime observations. Write a function to calculate the range of values in air temperature (meteorological record)) or water temperature (oceanographic record). Apply this function teach of the 3+ days for which you obtained data. Getting Started For this exercise, we want to work with multiple data files. Each data file in the index is one day, but we want to work with multiple days worth of data. How can we quickly and conveniently download multiple data files from the web? This is something= the Unix shell is really great at automating. The WHOI dataset we're using exposes multiple data files at unique URLs. Below is an example file from the 120th day of 2018. ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018120_OcntDat_s.C99 To download other days, we need only change one number in the URL: ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018120_OcnDat_s.C99 ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018119_OcnDat_s.C99 ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018118_OcnDat_s.C99 ... How can we automate this with the Unix shell? First we need to figure out which shell program to use. Recall that the Unix shell offers many different small programs; depending on which variant of the Unix shell we're using, a certain program might not be available. sh which wget which curl So you may have both installed. If you do, use wget instead of curl; both programs do the same thing. Downloading Online Datafiles with wget Here's an example shell script to get us started. We iterate over three (3) days (118, 119, 120), storing each day number in a variable called day. In each iteration, we use wget to download the file, inserting that day number stored in the variable day. ```sh cd cd Desktop for day in 118 119 120 do wget "ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018${day}_OcnDat_s.C99" done ``` Downloading Online Datafiles with curl Unlike wget, the curl program prints the downloaded text data directly to the screen. Remember how we dealt with taking screen output and redirecting it to a file? ```sh cd cd Desktop for day in 118 119 120 do curl "ftp://mvcodata.whoi.edu/pub/mvcodata/data/OcnDat_s/2018/2018${day}_OcnDat_s.C99" > 2018${day}_OcnDat_s.C99 done ``` Good Luck! Try the rest of the Capstone on your own. Helpful hints are provided throughout. You're encouraged to work with a partner but feel free to work independently if that suits you. The hints below use only the packages we've seen in Python 3 so far, but if you're feeling adventurous, the pandas package has more and better tools for dealing with mixed, tabular data like the meteorology and oceanographic records here. py import pandas as pd For help getting started with pandas, check out 10 Minutes to Pandas, in particular, the sections: Getting data in/out - CSV Viewing data Plotting data Hint: Combining Multiple Text Files in the Unix Shell Remember the cat program? sh cat 2018120_OcnDat_s.C99 You can provide multiple files to the cat program and it will combine them line-by-line. sh cat 2018120_OcnDat_s.C99 2018119_OcnDat_s.C99 2018118_OcnDat_s.C99 But this just prints everything out to the screen. Use redirection to store the output in a new file called ocean.txt or met.txt, depending on which data source you're using. Hint: Reading in Data Using Python The WHOI datasets are apparently space-delimited. They might also be called "fixed width" because each data column appears at the same distance along each line. End of explanation data[...,4] Explanation: Hint: Plotting Data in Python Revisit your notes from when we did this earlier! Remember you need to import the plotting capability in Jupyter Notebook: py import matplotlib.pyplot as pyplot %matplotlib inline Hint: Filter Data Using Python The fifth column contains the hour of the day. Recall that Python starts counting at zero, so column 5 is at position 4. The three dots (...) just mean "everything else" or, more specifically, "all the rows." Recall that with NumPy arrays, we count the number of rows, then columns: "rows comma columns." End of explanation np.in1d(data[...,4], range(7,19)) Explanation: The range() function in Python returns a list of consecutive integers between the first and the second number. The np.in1d function tests each element of our "hour" column to see if it is in the list of numbers from 7 to 18, inclusive. End of explanation daytime = data[np.in1d(data[...,4], range(7,19)),...] daytime.shape Explanation: To filter the full NumPy array to just those rows where the "hour" is between 7 and 18 (inclusive), we can take this vector of True and False values and put inside brackets, as below. Remember that the three dots (...) just mean "everything else" or, more specifically, "all the columns." End of explanation daytime[...,3] daytime[...,3] == 28 Explanation: Hint: Creating a Function to Calculate Temperature Ranges The range of daytime temperatures for a given day is the daily maximum temperature minus the daily minimum temperature. Create a single function to do this, then call it at least 3 times, once for each unique day in your dataset. How can you present this function with just the data for a given day? There are a few different ways. In both datasets, the 4th column (column 3 in Python, where we start counting from zero) has an integer representing the day of the month. End of explanation daytime.shape 108 / 3 Explanation: For another way to get all the records associated with a single day, remember that every day has the same number of records. Now that we've filtered to just the daytime records, there should be 36 records per day. End of explanation daytime[0:36,3] Explanation: We can slice the first 36 rows of our data table to obtain the first day. The second day would then be rows 37 through 72, and so on. End of explanation cursor.close() connection.close() Explanation: Connecting to SQLite with Python End of explanation
12,435	Given the following text description, write Python code to implement the functionality described below step by step Description: <a href='http Step1: Visualizing eclipse data Let us find some interesting data to generate elements from, before we consider how to customize them. Here is a dataset containing information about all the eclipses of the 21st century Step2: Here we have the date of each eclipse, what time of day the eclipse reached its peak in both local time and in UTC, the type of eclipse, its magnitude (fraction of the Sun's diameter obscured by the Moon) and the position of the peak in latitude and longitude. Let's see what happens if we pass this dataframe to the Curve element Step3: We see that, by default, the first dataframe column becomes the key dimension (corresponding to the x-axis) and the second column becomes the value dimension (corresponding to the y-axis). There is clearly structure in this data, but the plot is too highly compressed in the x direction to see much detail, and you may not like the particular color or line style. So we can start customizing the appearance of this curve using the HoloViews options system. Types of option If we want to change the appearance of what we can already see in the plot, we're no longer focusing on the data and metadata stored in the elements, but about details of the presentation. Details specific to the final plo tare handled by the separate "options" system, not the element objects. HoloViews allows you to set three types of options Step4: The top line uses a special IPython/Jupyter syntax called the %%opts cell magic to specify the width plot option for all Curve objects in this cell. %%opts accepts a simple specification where we pass the width=900 keyword argument to Curve as a plot option (denoted by the square brackets). Of course, there are other ways of applying options in HoloViews that do not require this IPython-specific syntax, but for this tutorial, we will only be covering the more-convenient magic-based syntax. You can read about the alternative approaches in the user guide. Step5: Aside Step6: Style options The plot options earlier instructed HoloViews to build a plot 900 pixels wide, when rendered with the Bokeh plotting extension. Now let's specify that the Bokeh glyph should be 'red' and slightly thicker, which is information passed on directly to Bokeh (making it a style option) Step7: Note how the plot options applied above to hour_curve are remembered! The %%opts magic is used to customize the object displayed as output for a particular code cell Step8: Switching to matplotlib Let us now view our curve with matplotlib using the %%output cell magic Step9: All our options are gone! This is because the options are associated with the corresponding plotting extension---if you switch back to 'bokeh', the options will be applicable again. In general, options have to be specific to backends; e.g. the line_width style option accepted by Bokeh is called linewidth in matplotlib Step10: The %output line magic In the two cells above we repeated %%output backend='matplotlib' to use matplotlib to render those two cells. Instead of repeating ourselves with the cell magic, we can use a "line magic" (similar syntax to the cell magic but with one %) to set things globally. Let us switch to matplotlib with a line magic and specify that we want SVG output Step11: Unlike the cell magic, the line magic doesn't need to be followed by any expression and can be used anywhere in the notebook. Both the %output and %opts line magics set things globally so it is recommended you declare them at the top of your notebooks. Now let us look at the SVG matplotlib output we requested Step12: Switching back to bokeh In previous releases of HoloViews, it was typical to switch to matplotlib in order to export to PNG or SVG, because Bokeh did not support these file formats. Since Bokeh 0.12.6 we can now easily use HoloViews to export Bokeh plots to a PNG file, as we will now demonstrate Step13: By passing fig='png' and a filename='eclipses' to %output we can both render to PNG and save the output to file Step14: Here we have requested PNG format using fig='png' and that the output is output to eclipses.png using filename='eclipses' Step15: Bokeh also has some SVG support, but it is not yet exposed in HoloViews. Using group and label The above examples showed how to customize by type, but HoloViews offers multiple additional levels of customization that should be sufficient to cover any purpose. For our last example, let us split our eclipse dataframe based on the type ('Total' or 'Partial') Step16: We'll now introduce the Spikes element, and display it with a large width and without a y-axis. We can specify those options for all following Spikes elements using the %opts line magic Step17: Now let us look at the hour of day at which these two types of eclipses occur (local time) by overlaying the two types of eclipse as Spikes elements. The problem then is finding a way to visually distinguish the spikes corresponding to the different ellipse types. We can do this using the element group and label introduced in the introduction to elements section as follows Step18: Using these options to distinguish between the two categories of data with the same type, you can now see clear patterns of grouping between the two types, with many more total eclipses around noon in local time. Similar techniques can be used to provide arbitrarily specific customizations when needed.	Python Code: import pandas as pd import holoviews as hv hv.extension('bokeh', 'matplotlib') Explanation: <a href='http://www.holoviews.org'><img src="assets/hv+bk.png" alt="HV+BK logos" width="40%;" align="left"/></a> <div style="float:right;"><h2>02. Customizing Visual Appearance</h2></div> Section 01 focused on specifying elements and simple collections of them. This section explains how the visual appearance can be adjusted to bring out the most salient aspects of your data, or just to make the style match the overall theme of your document. Preliminaries In the introduction to elements, hv.extension('bokeh') was used at the start to load and activate the bokeh plotting extension. In this notebook, we will also briefly use matplotlib which we will load, but not yet activate, by listing it second: End of explanation eclipses = pd.read_csv('../data/eclipses_21C.csv', parse_dates=['date']) eclipses.head() Explanation: Visualizing eclipse data Let us find some interesting data to generate elements from, before we consider how to customize them. Here is a dataset containing information about all the eclipses of the 21st century: End of explanation hv.Curve(eclipses) Explanation: Here we have the date of each eclipse, what time of day the eclipse reached its peak in both local time and in UTC, the type of eclipse, its magnitude (fraction of the Sun's diameter obscured by the Moon) and the position of the peak in latitude and longitude. Let's see what happens if we pass this dataframe to the Curve element: End of explanation %%opts Curve [width=900] hour_curve = hv.Curve(eclipses).redim.label(hour_local='Hour (local time)', date='Date (21st century)') hour_curve Explanation: We see that, by default, the first dataframe column becomes the key dimension (corresponding to the x-axis) and the second column becomes the value dimension (corresponding to the y-axis). There is clearly structure in this data, but the plot is too highly compressed in the x direction to see much detail, and you may not like the particular color or line style. So we can start customizing the appearance of this curve using the HoloViews options system. Types of option If we want to change the appearance of what we can already see in the plot, we're no longer focusing on the data and metadata stored in the elements, but about details of the presentation. Details specific to the final plo tare handled by the separate "options" system, not the element objects. HoloViews allows you to set three types of options: plot options: Options that tell HoloViews how to construct the plot. style options: Options that tell the underlying plotting extension (Bokeh, matplotlib, etc.) how to style the plot normalization options: Options that tell HoloViews how to normalize the various elements in the plot against each other (not covered in this tutorial) Plot options We noted that the data is too compressed in the x direction. Let us fix that by specifying the width plot option: End of explanation %%opts Curve [width=900 height=200] # Exercise: Try setting the height plot option of the Curve above. # Hint: the magic supports tab completion when the cursor is in the square brackets! # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve = hv.Curve(eclipses).redim.label(hour_local='Hour (local time)', date='Date (21st century)') hour_curve %%opts Curve [width=900 show_grid=True] # Exercise: Try enabling the boolean show_grid plot option for the curve above # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve = hv.Curve(eclipses).redim.label(hour_local='Hour (local time)', date='Date (21st century)') hour_curve %%opts Curve [width=900 xrotation=45] # Exercise: Try set the x-axis label rotation (in degrees) with the xrotation plot option # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve = hv.Curve(eclipses).redim.label(hour_local='Hour (local time)', date='Date (21st century)') hour_curve Explanation: The top line uses a special IPython/Jupyter syntax called the %%opts cell magic to specify the width plot option for all Curve objects in this cell. %%opts accepts a simple specification where we pass the width=900 keyword argument to Curve as a plot option (denoted by the square brackets). Of course, there are other ways of applying options in HoloViews that do not require this IPython-specific syntax, but for this tutorial, we will only be covering the more-convenient magic-based syntax. You can read about the alternative approaches in the user guide. End of explanation hv.help(hv.Curve, pattern='lod') # Example of help, matching 'lod' substring Explanation: Aside: hv.help Tab completion helps discover what keywords are available but you can get more complete help using the hv.help utility. For instance, to learn more about the options for hv.Curve run hv.help(hv.Curve): End of explanation %%opts Curve (color='red' line_width=2) # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve Explanation: Style options The plot options earlier instructed HoloViews to build a plot 900 pixels wide, when rendered with the Bokeh plotting extension. Now let's specify that the Bokeh glyph should be 'red' and slightly thicker, which is information passed on directly to Bokeh (making it a style option): End of explanation # Exercise: Display hour_curve without any new options to verify it stays red hour_curve %%opts Curve (color='red' line_width=1) # Exercise: Try setting the line_width style options to 1 # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve %%opts Curve (color='red' line_dash='dotdash') # Exercise: Try setting the line_dash style option to 'dotdash' # Note: The %%opts cell magic must appear at the top of the code cell! hour_curve Explanation: Note how the plot options applied above to hour_curve are remembered! The %%opts magic is used to customize the object displayed as output for a particular code cell: behind the scenes HoloViews has linked the specified options to the hour_curve object via a hidden integer id attribute. Having used the %%opts magic on hour_curve again, we have now associated the 'red' color style option to it. In the options specification syntax, style options are the keywords in parentheses and are keywords defined and used by Bokeh to style line glyphs. End of explanation %%output backend='matplotlib' hour_curve Explanation: Switching to matplotlib Let us now view our curve with matplotlib using the %%output cell magic: End of explanation %%output backend='matplotlib' %%opts Curve [aspect=4 fig_size=400 xrotation=90] (color='blue' linewidth=2) # Note: Both the %%output and %%opts cell magics must appear at the top of the code cell! hour_curve %%output backend='matplotlib' %%opts Curve [aspect=4 fig_size=400 xrotation=90] (color='blue' linewidth=2 linestyle='-.') # Exercise: Apply the matplotlib equivalent to line_dash above using linestyle='-.' # Note: Both the %%output and %%opts cell magics must appear at the top of the code cell! hour_curve Explanation: All our options are gone! This is because the options are associated with the corresponding plotting extension---if you switch back to 'bokeh', the options will be applicable again. In general, options have to be specific to backends; e.g. the line_width style option accepted by Bokeh is called linewidth in matplotlib: End of explanation %output backend='matplotlib' fig='svg' Explanation: The %output line magic In the two cells above we repeated %%output backend='matplotlib' to use matplotlib to render those two cells. Instead of repeating ourselves with the cell magic, we can use a "line magic" (similar syntax to the cell magic but with one %) to set things globally. Let us switch to matplotlib with a line magic and specify that we want SVG output: End of explanation %%opts Curve [aspect=4 fig_size=400 xrotation=70] (color='green' linestyle='--') hour_curve # Exercise: Verify for yourself that the output above is SVG and not PNG # You can do this by right-clicking above then selecting 'Open Image in a new Tab' (Chrome) or 'View Image' (Firefox) # Solution: Look at the URL in the new tab, it will start with 'data:image/svg+xml;base64,' as the output is SVG Explanation: Unlike the cell magic, the line magic doesn't need to be followed by any expression and can be used anywhere in the notebook. Both the %output and %opts line magics set things globally so it is recommended you declare them at the top of your notebooks. Now let us look at the SVG matplotlib output we requested: End of explanation %output backend='bokeh' Explanation: Switching back to bokeh In previous releases of HoloViews, it was typical to switch to matplotlib in order to export to PNG or SVG, because Bokeh did not support these file formats. Since Bokeh 0.12.6 we can now easily use HoloViews to export Bokeh plots to a PNG file, as we will now demonstrate: End of explanation %%output fig='png' filename='eclipses' hour_curve.clone() Explanation: By passing fig='png' and a filename='eclipses' to %output we can both render to PNG and save the output to file: End of explanation ls .png Explanation: Here we have requested PNG format using fig='png' and that the output is output to eclipses.png using filename='eclipses': End of explanation total_eclipses = eclipses[eclipses.type=='Total'] partial_eclipses = eclipses[eclipses.type=='Partial'] Explanation: Bokeh also has some SVG support, but it is not yet exposed in HoloViews. Using group and label The above examples showed how to customize by type, but HoloViews offers multiple additional levels of customization that should be sufficient to cover any purpose. For our last example, let us split our eclipse dataframe based on the type ('Total' or 'Partial'): End of explanation %opts Spikes [width=900 yaxis=None] Explanation: We'll now introduce the Spikes element, and display it with a large width and without a y-axis. We can specify those options for all following Spikes elements using the %opts line magic: End of explanation %%opts Spikes.Eclipses.Total (line_dash='solid') %%opts Spikes.Eclipses.Partial (line_dash='dotted') total = hv.Spikes(total_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Total') partial = hv.Spikes(partial_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Partial') (total partial).redim.label(hour_local='Local time (hour)') Explanation: Now let us look at the hour of day at which these two types of eclipses occur (local time) by overlaying the two types of eclipse as Spikes elements. The problem then is finding a way to visually distinguish the spikes corresponding to the different ellipse types. We can do this using the element group and label introduced in the introduction to elements section as follows: End of explanation # Exercise: Remove the two %%opts lines above and observe the effect # Solution: We can no longer distinguish between the total and partial eclipses as they all have solid lines! total = hv.Spikes(total_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Total') partial = hv.Spikes(partial_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Partial') (total * partial).redim.label(hour_local='Local time (hour)') %%opts Spikes.Eclipses.Total (line_dash='solid' color='black') %%opts Spikes.Eclipses.Partial (line_dash='solid' color='lightgray') # Exercise: Show all spikes with 'solid' line_dash, total eclipses in black and the partial ones in 'lightgray' # Note: The %%opts cell magic must appear at the top of the code cell! total = hv.Spikes(total_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Total') partial = hv.Spikes(partial_eclipses, kdims=['hour_local'], vdims=[], group='Eclipses', label='Partial') (total * partial).redim.label(hour_local='Local time (hour)') %%opts Spikes.Total_Eclipses (line_dash='solid' color='black') %%opts Spikes.Partial_Eclipses (line_dash='solid' color='lightgray') # Optional Exercise: Try differentiating the two sets of spikes by group and not label # Note: The %%opts cell magic must appear at the top of the code cell! total = hv.Spikes(total_eclipses, kdims=['hour_local'], vdims=[], group='Total_Eclipses') partial = hv.Spikes(partial_eclipses, kdims=['hour_local'], vdims=[], group='Partial_Eclipses') (total * partial).redim.label(hour_local='Local time (hour)') Explanation: Using these options to distinguish between the two categories of data with the same type, you can now see clear patterns of grouping between the two types, with many more total eclipses around noon in local time. Similar techniques can be used to provide arbitrarily specific customizations when needed. End of explanation
12,436	Given the following text description, write Python code to implement the functionality described below step by step Description: Review from the previous lecture In yesterday's Lecture 2, you learned how to use the numpy module, how to make your own functions, and how to import and export data. Below is a quick review before we move on to Lecture 3. Remember, to use the numpy module, first it must be imported Step1: You can do a lot with the numpy module. Below is an example to jog your memory Step2: Do you remember the Fibonacci sequence from yesterday's Lecture 1? Let's define our own function that will help us to write the Fibonacci sequence. Step3: Remember loops too? Let's get the first 10 numbers in the Fibonacci sequence. Step4: There's your quick review of numpy and functions along with a while loop thrown in. Now we can move on to the content of Lecture 3. Lecture 3 - Distributions, Histograms, and Curve Fitting In the previous lecture, you learned how to import the module numpy and how to use many of its associated functions. As you've seen, numpy gives us the ability to generate arrays of numbers using commands usch as np.linspace and others. In addition to these commands, you can also use numpy to generate distributions of numbers. The two most frequently used distributions are the following Step5: Let's generate a vector of length 5 populated with uniformly distributed random numbers. The function np.random.rand takes the array output size as an argument (in this case, 5). Step6: Additionally, you are not limited to one-dimensional arrays! Let's make a 5x5, two-dimensional array Step7: Great, so now you have a handle on generating uniform distributions. Let's quickly look at one more type of distribution. The normal distribution (randn) selects numbers from a Gaussian curve, sometimes called a bell curve, also from the interval [0,1). The equation for a Gaussian curve is the following Step8: So these numbers probably don't mean that much to you. Don't worry; they don't mean much to me either! Instead of trying to derive meaning from a list of numbers, let's actually plot these outputs and see what they look like. This will allow us to determine whether or not these distributions actually look like what we are expecting. How do we do that? The answer is with histograms! B. Plotting distributions Histogram documentation Step9: Now, let's plot a uniform distribution and take a look. Use what you learned above to define your variable X as a uniformly distributed array with 5000 elements. Step10: Now, let's use plt.hist to see what X looks like. First, run the cell below. Then, vary bins -- doing so will either increase or decrease the apparent effect of noise in your distribution. Step11: Nice job! Do you see why the "uniform distribution" is referred to as such? Next, let's take a look at the Gaussian distribution using histograms. In the cell below, generate a vector of length 5000, called X, from the normal (Gaussian) distribution and plot a histogram with 50 bins. HINT Step12: Nice job! You just plotted a Gaussian distribution with mean of 0 and a standard deviation of 1. As a reminder, this is considered the "standard" normal distribution, and it's not particularly interesting. We can transform the distribution given by np.random.randn (and make it more interesting!) using simple arithmetic. Run the cell below to see. How is the code below different from the code you've already written? Step13: Before moving onto the next section, vary the values of mu and sigma in the above code to see how your histogram changes. You should find that changing mu (the mean) affects the center of the distribution while changing sigma (the standard deviation) affects the width of the distribution. Take a look at the histograms you have generated and compare them. Do the histograms of the uniform and normal (Gaussian) distributions look different? If so, how? Describe your observations in the cell below. Step14: For simplicity's sake, we've used plt.hist without generating any return variables. Remember that plt.hist takes in your data (X) and the number of bins, and it makes histograms from it. In the process, plt.hist generates variables that you can store; we just haven't thus far. Run the cell below to see -- it should replot the Gaussian from above while also generating the output variables. Step15: Something that might be useful to you is that you can make use of variables outputted by plt.hist -- particularly bins and N. The bins array returned by plt.hist is longer (by one element) than the actual number of bins. Why? Because the bins array contains all the edges of the bins. For example, if you have 2 bins, you will have 3 edges. Does this make sense? So you can generate these outputs, but what can you do with them? You can average consecutive elements from the bins output to get, in a sense, a location of the center of a bin. Let's call it bin_avg. Then you can plot the number of observations in that bin (N) against the bin location (bin_avg). Step16: The plot above (red stars) should look like it overlays the histogram plot above it. If that's what you see, nice job! If not, let your instructor and/or TAs know before moving onto the next section. C. Checking your distributions with statistics If you ever want to check that your distributions are giving you what you expect, you can use numpy to calculate the mean and standard deviation of your distribution. Let's do this for X, our Gaussian distribution, and print the results. Run the cell below. Are your mean and standard deviation what you expect them to be? Step17: So you've learned how to generate distributions of numbers, plot them, and generate statistics on them. This is a great starting point, but let's try working with some real data! D. Visualizing and understanding real data Hope you're excited -- we're about to get our hands on some real data! Let's import a list of fluorescence lifetimes in nanoseconds from Nitrogen-Vacancy defects in diamond. (While it is not at all necessary to understand the physics behind this, know that this is indeed real data! You can read more about it at http Step18: Next, plot a histogram of this data set (play around with the number of bins, too). Step19: Now, calculate and print the mean and standard deviation of this distribution. Step20: Nice job! Now that you're used to working with real data, we're going to try to fit some more real data to known functions to gain a better understanding of that data. E. Basic curve fitting In this section, we're going to introduce you to the Python module known as scipy (short for Scientific Python). scipy allows you to perform a range of functions such as numerical integration and optimization. In particular, it's useful for data analysis, which we shall see shortly. In particular, we will do curve fitting using curve_fit from scipy.optimize. Curve fitting documentation Step21: We will show you an example, and then you get to try it out for yourself! We start by creating an equally-spaced numpy array x consisting of 100 numbers from -5 to 5. Try it out yourself below. Step22: Next, we will define a function $f(x) = \frac 1 3x^2+3$ that will square the elements in x and add an offset. Call this function f_scalar, and implement it (for scalar values) below. Step23: We will then vectorize the function to allow it to act on all elements of an array at once. Magic! Step24: Now we will add some noise to the array y using the np.random.rand() function and store it in a new variable called y_noisy. Important question Step25: Let's see what the y values look like now Step26: It seems like there's still a rough parabolic shape, so let's see if we can recover the original y values without any noise. We can treat this y_noisy as data values that we want to fit with a parabolic funciton. To do this, we first need to define the general form of a quadratic function Step27: Then, we want to find the optimal values of a, b, and c that will give a function that fits best to y_noisy. We do this using the curve_fit function in the following way Step28: Now that we have the fitted parameters, let's use quadratic to plot the fitted parabola alongside the noisy y values. Step29: And we can also compare y_fitted to the original y values without any noise Step30: Not a bad job for your first fit function! F. More advanced curve fitting In this section, you will visualize real data and plot a best-fit function to model the underlying physics. You just used curve_fit above to fit simulated data to a linear function. Using that code as your guide, combined with the steps below, you will use curve_fit to fit your real data to a non-linear function that you define. This exercise will combine most of what you've learned so far! Steps for using curve_fit Here is the basic outline on how to use curve_fit. As this is the last section, you will mostly be on your own. Try your best with new skills you have learned here and feel free to ask for help! 1) Load in your x and y data. You will be using "photopeak.txt", which is in the folder Data. HINT 1 Step31: So you've imported your data and plotted it. It should look similar to the figure below. Run the next cell to see. Step32: What type of function would you say this is? Think back to the distributions we've learned about today. Any ideas? Based on what you think, define your function below.	Python Code: import numpy as np Explanation: Review from the previous lecture In yesterday's Lecture 2, you learned how to use the numpy module, how to make your own functions, and how to import and export data. Below is a quick review before we move on to Lecture 3. Remember, to use the numpy module, first it must be imported: End of explanation np.linspace(0,10,11) Explanation: You can do a lot with the numpy module. Below is an example to jog your memory: End of explanation def myFib(a,b): return a+b Explanation: Do you remember the Fibonacci sequence from yesterday's Lecture 1? Let's define our own function that will help us to write the Fibonacci sequence. End of explanation fibLength = 10 #the length we want for our Fibonacci sequence fibSeq = np.zeros(fibLength) #make a numpy array of 10 zeros # Let's define the first 2 elements of the Fibonacci sequence fibSeq[0] = 0 fibSeq[1] = 1 i = 2 #with the first 2 elements defined, we can calculate the rest of the sequence beginning with the 3rd element while i-1 < fibLength-1: nextFib = myFib(fibSeq[i-2],fibSeq[i-1]) fibSeq[i] = nextFib i = i + 1 print(fibSeq) Explanation: Remember loops too? Let's get the first 10 numbers in the Fibonacci sequence. End of explanation import numpy as np Explanation: There's your quick review of numpy and functions along with a while loop thrown in. Now we can move on to the content of Lecture 3. Lecture 3 - Distributions, Histograms, and Curve Fitting In the previous lecture, you learned how to import the module numpy and how to use many of its associated functions. As you've seen, numpy gives us the ability to generate arrays of numbers using commands usch as np.linspace and others. In addition to these commands, you can also use numpy to generate distributions of numbers. The two most frequently used distributions are the following: the uniform distribution: np.random.rand the normal (Gaussian) distribution: np.random.randn (notice the "n" that distinguishes the functions for generating normal vs. uniform distributions) A. Generating distributions Let's start with the uniform distribution (rand), which gives numbers uniformly distributed over the interval [0,1). If you haven't already, import the numpy module. End of explanation np.random.rand(5) Explanation: Let's generate a vector of length 5 populated with uniformly distributed random numbers. The function np.random.rand takes the array output size as an argument (in this case, 5). End of explanation np.random.rand(5,5) Explanation: Additionally, you are not limited to one-dimensional arrays! Let's make a 5x5, two-dimensional array: End of explanation np.random.randn(5) Explanation: Great, so now you have a handle on generating uniform distributions. Let's quickly look at one more type of distribution. The normal distribution (randn) selects numbers from a Gaussian curve, sometimes called a bell curve, also from the interval [0,1). The equation for a Gaussian curve is the following: $f(x) = \frac{1}{\sqrt{2\pi\sigma^2}}e^{\frac{-(x-\mu)^2}{2\sigma^2}}$ where $\mu$ is the mean and $\sigma$ is the standard deviation. Don't worry about memorizing this equation, but do know that it exists and that numbers can be randomly drawn from it. In python, the command np.random.randn selects numbers from the "standard" normal distribution. All this means is that, in the equation above, $\mu$ (mean) = 0 and $\sigma$ (standard deviation ) 1. randn takes the size of the output as an argument just like rand does. Try running the cell below to see the numbers you get from a normal distribution. End of explanation import matplotlib.pyplot as plt %matplotlib inline Explanation: So these numbers probably don't mean that much to you. Don't worry; they don't mean much to me either! Instead of trying to derive meaning from a list of numbers, let's actually plot these outputs and see what they look like. This will allow us to determine whether or not these distributions actually look like what we are expecting. How do we do that? The answer is with histograms! B. Plotting distributions Histogram documentation: http://matplotlib.org/1.2.1/api/pyplot_api.html?highlight=hist#matplotlib.pyplot.hist Understanding distributions is perhaps best done by plotting them in a histogram. Lucky for us, matplotlib makes that very simple for us. To make a histogram, we use the command plt.hist, which takes -- at minimum -- a vector of values that we want to plot as a histogram. We can also specify the number of bins. First things first: let's import matplotlib: End of explanation #your code here X = ... Explanation: Now, let's plot a uniform distribution and take a look. Use what you learned above to define your variable X as a uniformly distributed array with 5000 elements. End of explanation plt.hist(X, bins=20); Explanation: Now, let's use plt.hist to see what X looks like. First, run the cell below. Then, vary bins -- doing so will either increase or decrease the apparent effect of noise in your distribution. End of explanation #your code here Explanation: Nice job! Do you see why the "uniform distribution" is referred to as such? Next, let's take a look at the Gaussian distribution using histograms. In the cell below, generate a vector of length 5000, called X, from the normal (Gaussian) distribution and plot a histogram with 50 bins. HINT: You will use a similar format as above when you defined and plotted a uniform distribution. End of explanation mu = 5 #the mean of the distribution sigma = 3 #the standard deviation X = sigma * np.random.randn(5000) + mu plt.hist(X,bins=50); Explanation: Nice job! You just plotted a Gaussian distribution with mean of 0 and a standard deviation of 1. As a reminder, this is considered the "standard" normal distribution, and it's not particularly interesting. We can transform the distribution given by np.random.randn (and make it more interesting!) using simple arithmetic. Run the cell below to see. How is the code below different from the code you've already written? End of explanation #write your observations here Explanation: Before moving onto the next section, vary the values of mu and sigma in the above code to see how your histogram changes. You should find that changing mu (the mean) affects the center of the distribution while changing sigma (the standard deviation) affects the width of the distribution. Take a look at the histograms you have generated and compare them. Do the histograms of the uniform and normal (Gaussian) distributions look different? If so, how? Describe your observations in the cell below. End of explanation N,bins,patches = plt.hist(X, bins=50) Explanation: For simplicity's sake, we've used plt.hist without generating any return variables. Remember that plt.hist takes in your data (X) and the number of bins, and it makes histograms from it. In the process, plt.hist generates variables that you can store; we just haven't thus far. Run the cell below to see -- it should replot the Gaussian from above while also generating the output variables. End of explanation bin_avg = (bins[1:]+bins[:-1])/2 plt.plot(bin_avg, N, 'r') plt.show() Explanation: Something that might be useful to you is that you can make use of variables outputted by plt.hist -- particularly bins and N. The bins array returned by plt.hist is longer (by one element) than the actual number of bins. Why? Because the bins array contains all the edges of the bins. For example, if you have 2 bins, you will have 3 edges. Does this make sense? So you can generate these outputs, but what can you do with them? You can average consecutive elements from the bins output to get, in a sense, a location of the center of a bin. Let's call it bin_avg. Then you can plot the number of observations in that bin (N) against the bin location (bin_avg). End of explanation mean = np.mean(X) std = np.std(X) print('mean: '+ repr(mean) ) print('standard deviation: ' + repr(std)) Explanation: The plot above (red stars) should look like it overlays the histogram plot above it. If that's what you see, nice job! If not, let your instructor and/or TAs know before moving onto the next section. C. Checking your distributions with statistics If you ever want to check that your distributions are giving you what you expect, you can use numpy to calculate the mean and standard deviation of your distribution. Let's do this for X, our Gaussian distribution, and print the results. Run the cell below. Are your mean and standard deviation what you expect them to be? End of explanation lifetimes = np.loadtxt('Data\LifetimeData.txt') Explanation: So you've learned how to generate distributions of numbers, plot them, and generate statistics on them. This is a great starting point, but let's try working with some real data! D. Visualizing and understanding real data Hope you're excited -- we're about to get our hands on some real data! Let's import a list of fluorescence lifetimes in nanoseconds from Nitrogen-Vacancy defects in diamond. (While it is not at all necessary to understand the physics behind this, know that this is indeed real data! You can read more about it at http://www.nature.com/articles/ncomms11820 if you are so inclined. This data is from Fig. 6a). Do you remember learning how to import data in yesterday's Lecture 2? The command you want to use is np.loadtxt. The data we'll be working with is called LifetimeData.txt, and it's located in the Data folder. End of explanation #your code here Explanation: Next, plot a histogram of this data set (play around with the number of bins, too). End of explanation #your code here Explanation: Now, calculate and print the mean and standard deviation of this distribution. End of explanation import numpy as np from scipy.optimize import curve_fit import matplotlib.pyplot as plt %matplotlib inline Explanation: Nice job! Now that you're used to working with real data, we're going to try to fit some more real data to known functions to gain a better understanding of that data. E. Basic curve fitting In this section, we're going to introduce you to the Python module known as scipy (short for Scientific Python). scipy allows you to perform a range of functions such as numerical integration and optimization. In particular, it's useful for data analysis, which we shall see shortly. In particular, we will do curve fitting using curve_fit from scipy.optimize. Curve fitting documentation: https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.optimize.curve_fit.html In this section, you will learn how to use curve fitting on simulated data. Next will be real data! First, let's load the modules. End of explanation # your code here Explanation: We will show you an example, and then you get to try it out for yourself! We start by creating an equally-spaced numpy array x consisting of 100 numbers from -5 to 5. Try it out yourself below. End of explanation # your code here Explanation: Next, we will define a function $f(x) = \frac 1 3x^2+3$ that will square the elements in x and add an offset. Call this function f_scalar, and implement it (for scalar values) below. End of explanation f = np.vectorize(f_scalar) y = f(x) Explanation: We will then vectorize the function to allow it to act on all elements of an array at once. Magic! End of explanation # your code here Explanation: Now we will add some noise to the array y using the np.random.rand() function and store it in a new variable called y_noisy. Important question: What value for the array size should we pass into this function? End of explanation plt.plot(x,y_noisy) Explanation: Let's see what the y values look like now End of explanation def quadratic(x,a,b,c): return ax*2 + bx + c Explanation: It seems like there's still a rough parabolic shape, so let's see if we can recover the original y values without any noise. We can treat this y_noisy as data values that we want to fit with a parabolic funciton. To do this, we first need to define the general form of a quadratic function: End of explanation optimal_values, _ = curve_fit(quadratic,x,y_noisy) a = optimal_values[0] b = optimal_values[1] c = optimal_values[2] print(a, b, c) Explanation: Then, we want to find the optimal values of a, b, and c that will give a function that fits best to y_noisy. We do this using the curve_fit function in the following way: curve_fit(f,xdata,ydata) where f is the model we're fitting to (quadratic in this case). This function will return the optimal values for a, b, and c in a list. Try it out! End of explanation y_fitted = quadratic(x,a,b,c) plt.plot(x,y_fitted) plt.plot(x,y_noisy) Explanation: Now that we have the fitted parameters, let's use quadratic to plot the fitted parabola alongside the noisy y values. End of explanation plt.plot(x,y_fitted) plt.plot(x,y) Explanation: And we can also compare y_fitted to the original y values without any noise: End of explanation # Step 1: Import the data # Step 2: Plot the data to see what it looks like data = np.loadtxt("Data/photopeak.txt") x_data = data[:,0] y_data = data[:,1] plt.scatter(x,y) Explanation: Not a bad job for your first fit function! F. More advanced curve fitting In this section, you will visualize real data and plot a best-fit function to model the underlying physics. You just used curve_fit above to fit simulated data to a linear function. Using that code as your guide, combined with the steps below, you will use curve_fit to fit your real data to a non-linear function that you define. This exercise will combine most of what you've learned so far! Steps for using curve_fit Here is the basic outline on how to use curve_fit. As this is the last section, you will mostly be on your own. Try your best with new skills you have learned here and feel free to ask for help! 1) Load in your x and y data. You will be using "photopeak.txt", which is in the folder Data. HINT 1: When you load your data, I recommend making use of the usecols and unpack argument. HINT 2: Make sure the arrays are the same length! 2) Plot this data to see what it looks like. Determine the function your data most resembles. 3) Define the function to which your data will be fit. 4) PART A: Use curve_fit and point the output to popt and pcov. These are the fitted parameters (popt) and their estimated errors (pcov). 4) PART B - OPTIONAL (only do this if you get through all the other steps): Input a guess (p0) and bounds (bounds) into curve_fit. For p0, I would suggest [0.5, 0.1, 5]. 5) Pass the popt parameters into the function you've defined to create the model fit. 6) Plot your data and your fitted function. 7) Pat yourself on the back! End of explanation from IPython.display import display, Image display(Image(filename='Data/photopeak.png')) Explanation: So you've imported your data and plotted it. It should look similar to the figure below. Run the next cell to see. End of explanation # Step 3: Define your function here def gaussian(x,A,mu,sigma): pi = np.pi return A/np.sqrt(2pisigma)np.exp(-(x-mu)2/(2sigma**2)) # Step 3.5: SANITY CHECK! Use this step as a way to check that the function you defined above is mathematically correct. x = np.linspace(-8,12,100) A = 1 mu = 2 sigma = 3 y = gaussian(x,A,mu,sigma) plt.plot(x,y) # Step 4: Use curve_fit to generate your output parameters popt,pcov = curve_fit(gaussian,x_data,y_data) # Step 5: Generate your model fit y_fitted = gaussian(x_data,popt[0],popt[1],popt[2]) plt.scatter(x_data,y_fitted) plt.scatter(x_data,y_data) # Step 6: Plot the best fit function and the scatter plot of data Explanation: What type of function would you say this is? Think back to the distributions we've learned about today. Any ideas? Based on what you think, define your function below. End of explanation
12,437	Given the following text problem statement, write Python code to implement the functionality described below in problem statement Problem: I'm using tensorflow 2.10.0.	Problem: import tensorflow as tf A = tf.constant([-0.5, -0.1, 0, 0.1, 0.5, 2], dtype=tf.float32) def g(A): return tf.math.reciprocal(A) result = g(A.__copy__())
12,438	Given the following text description, write Python code to implement the functionality described below step by step Description: Time Maps inspiration from https Step1: the example in the blog post is for a heat map of the amount of time in between events in a sequence. Step2: Our data file includes equal intervals, so this approach is worthless Step3: However, perhaps the axes could reflect time of day and day of week to show mean values for those instead. Step4: This data file is every 30 mins...	Python Code: import os; os.sys.path.append(os.path.dirname(os.path.abspath('.'))) # for relative imports from utils.nab_data import NABData import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline data = NABData() data.summary().head() data.data.keys() data.plot('nyc_taxi') Explanation: Time Maps inspiration from https://districtdatalabs.silvrback.com/time-maps-visualizing-discrete-events-across-many-timescales End of explanation import scipy.ndimage as ndi df = data['nyc_taxi'] times = df.index # calculate time differences: diffs = np.diff(times) xcoords = diffs[:-1] # all differences except the last ycoords = diffs[1:] # all differences except the first Nside=256 # this is the number of bins along x and y for the histogram width=8 # the width of the Gaussian function along x and y when applying the blur operation H = np.zeros((Nside,Nside)) # a 'histogram' matrix that counts the number of points in each grid-square max_diff = np.max(diffs) # maximum time difference x_heat = (Nside-1)xcoords/max_diff # the xy coordinates scaled to the size of the matrix y_heat = (Nside-1)ycoords/max_diff # subtract 1 since Python starts counting at 0, unlike Fortran and R for i in range(len(xcoords)): # loop over all points to calculate the population of each bin H[x_heat[i], y_heat[i]] += 1 # Increase count by 1 #here, the integer part of x/y_heat[i] is automatically taken H = ndi.gaussian_filter(H,width) # apply Gaussian blur H = np.transpose(H) # so that the orientation is the same as the scatter plot plt.imshow(H, origin='lower') # display H as an image plt.show() Explanation: the example in the blog post is for a heat map of the amount of time in between events in a sequence. End of explanation len(set(np.diff(data['nyc_taxi'].index))) Explanation: Our data file includes equal intervals, so this approach is worthless End of explanation df.head() Explanation: However, perhaps the axes could reflect time of day and day of week to show mean values for those instead. End of explanation df.index[0].weekday() np.unique(df.index.map(lambda x: x.weekday())) days_legend = dict(zip(range(7), ['Mon','Tue','Wed','Thur','Fri','Sat','Sun'])) days_legend day_masks = dict(zip(range(7), [df.index.map(lambda x: x.weekday() == d) for d in range(7)])) df.loc[day_masks[0]].shape times = np.unique(df.index.map(lambda x: x.time())) tindex = df.index.map(lambda x: x.time()) time_masks = dict(zip(times, [(tindex == t) for t in times])) k = time_masks.keys()[0] print k print df.loc[time_masks[k]].shape dtmap = pd.DataFrame(np.zeros((len(time_masks), len(day_masks))), index=sorted(times), columns=range(7)) print dtmap.shape fn = np.mean for day, daymask in day_masks.iteritems(): for time, timemask in time_masks.iteritems(): val = fn(df.loc[daymask & timemask]) dtmap.loc[time, day] = val.values dtmap.head() fig = plt.figure(figsize=(5, 15)) plt.imshow(dtmap, origin='lower') # display H as an image plt.yticks(range(dtmap.shape[0])[::4], sorted(times)[::4]) plt.xticks(range(7), [days_legend[x] for x in range(7)], rotation=60) plt.colorbar() plt.show() Explanation: This data file is every 30 mins... End of explanation
12,439	Given the following text description, write Python code to implement the functionality described below step by step Description: ES-DOC CMIP6 Model Properties - Atmos MIP Era Step1: Document Authors Set document authors Step2: Document Contributors Specify document contributors Step3: Document Publication Specify document publication status Step4: Document Table of Contents 1. Key Properties --> Overview 2. Key Properties --> Resolution 3. Key Properties --> Timestepping 4. Key Properties --> Orography 5. Grid --> Discretisation 6. Grid --> Discretisation --> Horizontal 7. Grid --> Discretisation --> Vertical 8. Dynamical Core 9. Dynamical Core --> Top Boundary 10. Dynamical Core --> Lateral Boundary 11. Dynamical Core --> Diffusion Horizontal 12. Dynamical Core --> Advection Tracers 13. Dynamical Core --> Advection Momentum 14. Radiation 15. Radiation --> Shortwave Radiation 16. Radiation --> Shortwave GHG 17. Radiation --> Shortwave Cloud Ice 18. Radiation --> Shortwave Cloud Liquid 19. Radiation --> Shortwave Cloud Inhomogeneity 20. Radiation --> Shortwave Aerosols 21. Radiation --> Shortwave Gases 22. Radiation --> Longwave Radiation 23. Radiation --> Longwave GHG 24. Radiation --> Longwave Cloud Ice 25. Radiation --> Longwave Cloud Liquid 26. Radiation --> Longwave Cloud Inhomogeneity 27. Radiation --> Longwave Aerosols 28. Radiation --> Longwave Gases 29. Turbulence Convection 30. Turbulence Convection --> Boundary Layer Turbulence 31. Turbulence Convection --> Deep Convection 32. Turbulence Convection --> Shallow Convection 33. Microphysics Precipitation 34. Microphysics Precipitation --> Large Scale Precipitation 35. Microphysics Precipitation --> Large Scale Cloud Microphysics 36. Cloud Scheme 37. Cloud Scheme --> Optical Cloud Properties 38. Cloud Scheme --> Sub Grid Scale Water Distribution 39. Cloud Scheme --> Sub Grid Scale Ice Distribution 40. Observation Simulation 41. Observation Simulation --> Isscp Attributes 42. Observation Simulation --> Cosp Attributes 43. Observation Simulation --> Radar Inputs 44. Observation Simulation --> Lidar Inputs 45. Gravity Waves 46. Gravity Waves --> Orographic Gravity Waves 47. Gravity Waves --> Non Orographic Gravity Waves 48. Solar 49. Solar --> Solar Pathways 50. Solar --> Solar Constant 51. Solar --> Orbital Parameters 52. Solar --> Insolation Ozone 53. Volcanos 54. Volcanos --> Volcanoes Treatment 1. Key Properties --> Overview Top level key properties 1.1. Model Overview Is Required Step5: 1.2. Model Name Is Required Step6: 1.3. Model Family Is Required Step7: 1.4. Basic Approximations Is Required Step8: 2. Key Properties --> Resolution Characteristics of the model resolution 2.1. Horizontal Resolution Name Is Required Step9: 2.2. Canonical Horizontal Resolution Is Required Step10: 2.3. Range Horizontal Resolution Is Required Step11: 2.4. Number Of Vertical Levels Is Required Step12: 2.5. High Top Is Required Step13: 3. Key Properties --> Timestepping Characteristics of the atmosphere model time stepping 3.1. Timestep Dynamics Is Required Step14: 3.2. Timestep Shortwave Radiative Transfer Is Required Step15: 3.3. Timestep Longwave Radiative Transfer Is Required Step16: 4. Key Properties --> Orography Characteristics of the model orography 4.1. Type Is Required Step17: 4.2. Changes Is Required Step18: 5. Grid --> Discretisation Atmosphere grid discretisation 5.1. Overview Is Required Step19: 6. Grid --> Discretisation --> Horizontal Atmosphere discretisation in the horizontal 6.1. Scheme Type Is Required Step20: 6.2. Scheme Method Is Required Step21: 6.3. Scheme Order Is Required Step22: 6.4. Horizontal Pole Is Required Step23: 6.5. Grid Type Is Required Step24: 7. Grid --> Discretisation --> Vertical Atmosphere discretisation in the vertical 7.1. Coordinate Type Is Required Step25: 8. Dynamical Core Characteristics of the dynamical core 8.1. Overview Is Required Step26: 8.2. Name Is Required Step27: 8.3. Timestepping Type Is Required Step28: 8.4. Prognostic Variables Is Required Step29: 9. Dynamical Core --> Top Boundary Type of boundary layer at the top of the model 9.1. Top Boundary Condition Is Required Step30: 9.2. Top Heat Is Required Step31: 9.3. Top Wind Is Required Step32: 10. Dynamical Core --> Lateral Boundary Type of lateral boundary condition (if the model is a regional model) 10.1. Condition Is Required Step33: 11. Dynamical Core --> Diffusion Horizontal Horizontal diffusion scheme 11.1. Scheme Name Is Required Step34: 11.2. Scheme Method Is Required Step35: 12. Dynamical Core --> Advection Tracers Tracer advection scheme 12.1. Scheme Name Is Required Step36: 12.2. Scheme Characteristics Is Required Step37: 12.3. Conserved Quantities Is Required Step38: 12.4. Conservation Method Is Required Step39: 13. Dynamical Core --> Advection Momentum Momentum advection scheme 13.1. Scheme Name Is Required Step40: 13.2. Scheme Characteristics Is Required Step41: 13.3. Scheme Staggering Type Is Required Step42: 13.4. Conserved Quantities Is Required Step43: 13.5. Conservation Method Is Required Step44: 14. Radiation Characteristics of the atmosphere radiation process 14.1. Aerosols Is Required Step45: 15. Radiation --> Shortwave Radiation Properties of the shortwave radiation scheme 15.1. Overview Is Required Step46: 15.2. Name Is Required Step47: 15.3. Spectral Integration Is Required Step48: 15.4. Transport Calculation Is Required Step49: 15.5. Spectral Intervals Is Required Step50: 16. Radiation --> Shortwave GHG Representation of greenhouse gases in the shortwave radiation scheme 16.1. Greenhouse Gas Complexity Is Required Step51: 16.2. ODS Is Required Step52: 16.3. Other Flourinated Gases Is Required Step53: 17. Radiation --> Shortwave Cloud Ice Shortwave radiative properties of ice crystals in clouds 17.1. General Interactions Is Required Step54: 17.2. Physical Representation Is Required Step55: 17.3. Optical Methods Is Required Step56: 18. Radiation --> Shortwave Cloud Liquid Shortwave radiative properties of liquid droplets in clouds 18.1. General Interactions Is Required Step57: 18.2. Physical Representation Is Required Step58: 18.3. Optical Methods Is Required Step59: 19. Radiation --> Shortwave Cloud Inhomogeneity Cloud inhomogeneity in the shortwave radiation scheme 19.1. Cloud Inhomogeneity Is Required Step60: 20. Radiation --> Shortwave Aerosols Shortwave radiative properties of aerosols 20.1. General Interactions Is Required Step61: 20.2. Physical Representation Is Required Step62: 20.3. Optical Methods Is Required Step63: 21. Radiation --> Shortwave Gases Shortwave radiative properties of gases 21.1. General Interactions Is Required Step64: 22. Radiation --> Longwave Radiation Properties of the longwave radiation scheme 22.1. Overview Is Required Step65: 22.2. Name Is Required Step66: 22.3. Spectral Integration Is Required Step67: 22.4. Transport Calculation Is Required Step68: 22.5. Spectral Intervals Is Required Step69: 23. Radiation --> Longwave GHG Representation of greenhouse gases in the longwave radiation scheme 23.1. Greenhouse Gas Complexity Is Required Step70: 23.2. ODS Is Required Step71: 23.3. Other Flourinated Gases Is Required Step72: 24. Radiation --> Longwave Cloud Ice Longwave radiative properties of ice crystals in clouds 24.1. General Interactions Is Required Step73: 24.2. Physical Reprenstation Is Required Step74: 24.3. Optical Methods Is Required Step75: 25. Radiation --> Longwave Cloud Liquid Longwave radiative properties of liquid droplets in clouds 25.1. General Interactions Is Required Step76: 25.2. Physical Representation Is Required Step77: 25.3. Optical Methods Is Required Step78: 26. Radiation --> Longwave Cloud Inhomogeneity Cloud inhomogeneity in the longwave radiation scheme 26.1. Cloud Inhomogeneity Is Required Step79: 27. Radiation --> Longwave Aerosols Longwave radiative properties of aerosols 27.1. General Interactions Is Required Step80: 27.2. Physical Representation Is Required Step81: 27.3. Optical Methods Is Required Step82: 28. Radiation --> Longwave Gases Longwave radiative properties of gases 28.1. General Interactions Is Required Step83: 29. Turbulence Convection Atmosphere Convective Turbulence and Clouds 29.1. Overview Is Required Step84: 30. Turbulence Convection --> Boundary Layer Turbulence Properties of the boundary layer turbulence scheme 30.1. Scheme Name Is Required Step85: 30.2. Scheme Type Is Required Step86: 30.3. Closure Order Is Required Step87: 30.4. Counter Gradient Is Required Step88: 31. Turbulence Convection --> Deep Convection Properties of the deep convection scheme 31.1. Scheme Name Is Required Step89: 31.2. Scheme Type Is Required Step90: 31.3. Scheme Method Is Required Step91: 31.4. Processes Is Required Step92: 31.5. Microphysics Is Required Step93: 32. Turbulence Convection --> Shallow Convection Properties of the shallow convection scheme 32.1. Scheme Name Is Required Step94: 32.2. Scheme Type Is Required Step95: 32.3. Scheme Method Is Required Step96: 32.4. Processes Is Required Step97: 32.5. Microphysics Is Required Step98: 33. Microphysics Precipitation Large Scale Cloud Microphysics and Precipitation 33.1. Overview Is Required Step99: 34. Microphysics Precipitation --> Large Scale Precipitation Properties of the large scale precipitation scheme 34.1. Scheme Name Is Required Step100: 34.2. Hydrometeors Is Required Step101: 35. Microphysics Precipitation --> Large Scale Cloud Microphysics Properties of the large scale cloud microphysics scheme 35.1. Scheme Name Is Required Step102: 35.2. Processes Is Required Step103: 36. Cloud Scheme Characteristics of the cloud scheme 36.1. Overview Is Required Step104: 36.2. Name Is Required Step105: 36.3. Atmos Coupling Is Required Step106: 36.4. Uses Separate Treatment Is Required Step107: 36.5. Processes Is Required Step108: 36.6. Prognostic Scheme Is Required Step109: 36.7. Diagnostic Scheme Is Required Step110: 36.8. Prognostic Variables Is Required Step111: 37. Cloud Scheme --> Optical Cloud Properties Optical cloud properties 37.1. Cloud Overlap Method Is Required Step112: 37.2. Cloud Inhomogeneity Is Required Step113: 38. Cloud Scheme --> Sub Grid Scale Water Distribution Sub-grid scale water distribution 38.1. Type Is Required Step114: 38.2. Function Name Is Required Step115: 38.3. Function Order Is Required Step116: 38.4. Convection Coupling Is Required Step117: 39. Cloud Scheme --> Sub Grid Scale Ice Distribution Sub-grid scale ice distribution 39.1. Type Is Required Step118: 39.2. Function Name Is Required Step119: 39.3. Function Order Is Required Step120: 39.4. Convection Coupling Is Required Step121: 40. Observation Simulation Characteristics of observation simulation 40.1. Overview Is Required Step122: 41. Observation Simulation --> Isscp Attributes ISSCP Characteristics 41.1. Top Height Estimation Method Is Required Step123: 41.2. Top Height Direction Is Required Step124: 42. Observation Simulation --> Cosp Attributes CFMIP Observational Simulator Package attributes 42.1. Run Configuration Is Required Step125: 42.2. Number Of Grid Points Is Required Step126: 42.3. Number Of Sub Columns Is Required Step127: 42.4. Number Of Levels Is Required Step128: 43. Observation Simulation --> Radar Inputs Characteristics of the cloud radar simulator 43.1. Frequency Is Required Step129: 43.2. Type Is Required Step130: 43.3. Gas Absorption Is Required Step131: 43.4. Effective Radius Is Required Step132: 44. Observation Simulation --> Lidar Inputs Characteristics of the cloud lidar simulator 44.1. Ice Types Is Required Step133: 44.2. Overlap Is Required Step134: 45. Gravity Waves Characteristics of the parameterised gravity waves in the atmosphere, whether from orography or other sources. 45.1. Overview Is Required Step135: 45.2. Sponge Layer Is Required Step136: 45.3. Background Is Required Step137: 45.4. Subgrid Scale Orography Is Required Step138: 46. Gravity Waves --> Orographic Gravity Waves Gravity waves generated due to the presence of orography 46.1. Name Is Required Step139: 46.2. Source Mechanisms Is Required Step140: 46.3. Calculation Method Is Required Step141: 46.4. Propagation Scheme Is Required Step142: 46.5. Dissipation Scheme Is Required Step143: 47. Gravity Waves --> Non Orographic Gravity Waves Gravity waves generated by non-orographic processes. 47.1. Name Is Required Step144: 47.2. Source Mechanisms Is Required Step145: 47.3. Calculation Method Is Required Step146: 47.4. Propagation Scheme Is Required Step147: 47.5. Dissipation Scheme Is Required Step148: 48. Solar Top of atmosphere solar insolation characteristics 48.1. Overview Is Required Step149: 49. Solar --> Solar Pathways Pathways for solar forcing of the atmosphere 49.1. Pathways Is Required Step150: 50. Solar --> Solar Constant Solar constant and top of atmosphere insolation characteristics 50.1. Type Is Required Step151: 50.2. Fixed Value Is Required Step152: 50.3. Transient Characteristics Is Required Step153: 51. Solar --> Orbital Parameters Orbital parameters and top of atmosphere insolation characteristics 51.1. Type Is Required Step154: 51.2. Fixed Reference Date Is Required Step155: 51.3. Transient Method Is Required Step156: 51.4. Computation Method Is Required Step157: 52. Solar --> Insolation Ozone Impact of solar insolation on stratospheric ozone 52.1. Solar Ozone Impact Is Required Step158: 53. Volcanos Characteristics of the implementation of volcanoes 53.1. Overview Is Required Step159: 54. Volcanos --> Volcanoes Treatment Treatment of volcanoes in the atmosphere 54.1. Volcanoes Implementation Is Required	Python Code: # DO NOT EDIT ! from pyesdoc.ipython.model_topic import NotebookOutput # DO NOT EDIT ! DOC = NotebookOutput('cmip6', 'ncc', 'noresm2-mh', 'atmos') Explanation: ES-DOC CMIP6 Model Properties - Atmos MIP Era: CMIP6 Institute: NCC Source ID: NORESM2-MH Topic: Atmos Sub-Topics: Dynamical Core, Radiation, Turbulence Convection, Microphysics Precipitation, Cloud Scheme, Observation Simulation, Gravity Waves, Solar, Volcanos. Properties: 156 (127 required) Model descriptions: Model description details Initialized From: -- Notebook Help: Goto notebook help page Notebook Initialised: 2018-02-15 16:54:24 Document Setup IMPORTANT: to be executed each time you run the notebook End of explanation # Set as follows: DOC.set_author("name", "email") # TODO - please enter value(s) Explanation: Document Authors Set document authors End of explanation # Set as follows: DOC.set_contributor("name", "email") # TODO - please enter value(s) Explanation: Document Contributors Specify document contributors End of explanation # Set publication status: # 0=do not publish, 1=publish. DOC.set_publication_status(0) Explanation: Document Publication Specify document publication status End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.overview.model_overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: Document Table of Contents 1. Key Properties --> Overview 2. Key Properties --> Resolution 3. Key Properties --> Timestepping 4. Key Properties --> Orography 5. Grid --> Discretisation 6. Grid --> Discretisation --> Horizontal 7. Grid --> Discretisation --> Vertical 8. Dynamical Core 9. Dynamical Core --> Top Boundary 10. Dynamical Core --> Lateral Boundary 11. Dynamical Core --> Diffusion Horizontal 12. Dynamical Core --> Advection Tracers 13. Dynamical Core --> Advection Momentum 14. Radiation 15. Radiation --> Shortwave Radiation 16. Radiation --> Shortwave GHG 17. Radiation --> Shortwave Cloud Ice 18. Radiation --> Shortwave Cloud Liquid 19. Radiation --> Shortwave Cloud Inhomogeneity 20. Radiation --> Shortwave Aerosols 21. Radiation --> Shortwave Gases 22. Radiation --> Longwave Radiation 23. Radiation --> Longwave GHG 24. Radiation --> Longwave Cloud Ice 25. Radiation --> Longwave Cloud Liquid 26. Radiation --> Longwave Cloud Inhomogeneity 27. Radiation --> Longwave Aerosols 28. Radiation --> Longwave Gases 29. Turbulence Convection 30. Turbulence Convection --> Boundary Layer Turbulence 31. Turbulence Convection --> Deep Convection 32. Turbulence Convection --> Shallow Convection 33. Microphysics Precipitation 34. Microphysics Precipitation --> Large Scale Precipitation 35. Microphysics Precipitation --> Large Scale Cloud Microphysics 36. Cloud Scheme 37. Cloud Scheme --> Optical Cloud Properties 38. Cloud Scheme --> Sub Grid Scale Water Distribution 39. Cloud Scheme --> Sub Grid Scale Ice Distribution 40. Observation Simulation 41. Observation Simulation --> Isscp Attributes 42. Observation Simulation --> Cosp Attributes 43. Observation Simulation --> Radar Inputs 44. Observation Simulation --> Lidar Inputs 45. Gravity Waves 46. Gravity Waves --> Orographic Gravity Waves 47. Gravity Waves --> Non Orographic Gravity Waves 48. Solar 49. Solar --> Solar Pathways 50. Solar --> Solar Constant 51. Solar --> Orbital Parameters 52. Solar --> Insolation Ozone 53. Volcanos 54. Volcanos --> Volcanoes Treatment 1. Key Properties --> Overview Top level key properties 1.1. Model Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview of atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.overview.model_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 1.2. Model Name Is Required: TRUE    Type: STRING    Cardinality: 1.1 Name of atmosphere model code (CAM 4.0, ARPEGE 3.2,...) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.overview.model_family') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "AGCM" # "ARCM" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 1.3. Model Family Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Type of atmospheric model. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.overview.basic_approximations') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "primitive equations" # "non-hydrostatic" # "anelastic" # "Boussinesq" # "hydrostatic" # "quasi-hydrostatic" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 1.4. Basic Approximations Is Required: TRUE    Type: ENUM    Cardinality: 1.N Basic approximations made in the atmosphere. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.resolution.horizontal_resolution_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2. Key Properties --> Resolution Characteristics of the model resolution 2.1. Horizontal Resolution Name Is Required: TRUE    Type: STRING    Cardinality: 1.1 This is a string usually used by the modelling group to describe the resolution of the model grid, e.g. T42, N48. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.resolution.canonical_horizontal_resolution') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2.2. Canonical Horizontal Resolution Is Required: TRUE    Type: STRING    Cardinality: 1.1 Expression quoted for gross comparisons of resolution, e.g. 2.5 x 3.75 degrees lat-lon. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.resolution.range_horizontal_resolution') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 2.3. Range Horizontal Resolution Is Required: TRUE    Type: STRING    Cardinality: 1.1 Range of horizontal resolution with spatial details, eg. 1 deg (Equator) - 0.5 deg End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.resolution.number_of_vertical_levels') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 2.4. Number Of Vertical Levels Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Number of vertical levels resolved on the computational grid. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.resolution.high_top') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 2.5. High Top Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Does the atmosphere have a high-top? High-Top atmospheres have a fully resolved stratosphere with a model top above the stratopause. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.timestepping.timestep_dynamics') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 3. Key Properties --> Timestepping Characteristics of the atmosphere model time stepping 3.1. Timestep Dynamics Is Required: TRUE    Type: STRING    Cardinality: 1.1 Timestep for the dynamics, e.g. 30 min. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.timestepping.timestep_shortwave_radiative_transfer') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 3.2. Timestep Shortwave Radiative Transfer Is Required: FALSE    Type: STRING    Cardinality: 0.1 Timestep for the shortwave radiative transfer, e.g. 1.5 hours. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.timestepping.timestep_longwave_radiative_transfer') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 3.3. Timestep Longwave Radiative Transfer Is Required: FALSE    Type: STRING    Cardinality: 0.1 Timestep for the longwave radiative transfer, e.g. 3 hours. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.orography.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "present day" # "modified" # TODO - please enter value(s) Explanation: 4. Key Properties --> Orography Characteristics of the model orography 4.1. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Time adaptation of the orography. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.key_properties.orography.changes') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "related to ice sheets" # "related to tectonics" # "modified mean" # "modified variance if taken into account in model (cf gravity waves)" # TODO - please enter value(s) Explanation: 4.2. Changes Is Required: TRUE    Type: ENUM    Cardinality: 1.N If the orography type is modified describe the time adaptation changes. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 5. Grid --> Discretisation Atmosphere grid discretisation 5.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of grid discretisation in the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.horizontal.scheme_type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "spectral" # "fixed grid" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 6. Grid --> Discretisation --> Horizontal Atmosphere discretisation in the horizontal 6.1. Scheme Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Horizontal discretisation type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.horizontal.scheme_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "finite elements" # "finite volumes" # "finite difference" # "centered finite difference" # TODO - please enter value(s) Explanation: 6.2. Scheme Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Horizontal discretisation method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.horizontal.scheme_order') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "second" # "third" # "fourth" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 6.3. Scheme Order Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Horizontal discretisation function order End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.horizontal.horizontal_pole') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "filter" # "pole rotation" # "artificial island" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 6.4. Horizontal Pole Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Horizontal discretisation pole singularity treatment End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.horizontal.grid_type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Gaussian" # "Latitude-Longitude" # "Cubed-Sphere" # "Icosahedral" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 6.5. Grid Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Horizontal grid type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.grid.discretisation.vertical.coordinate_type') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "isobaric" # "sigma" # "hybrid sigma-pressure" # "hybrid pressure" # "vertically lagrangian" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 7. Grid --> Discretisation --> Vertical Atmosphere discretisation in the vertical 7.1. Coordinate Type Is Required: TRUE    Type: ENUM    Cardinality: 1.N Type of vertical coordinate system End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 8. Dynamical Core Characteristics of the dynamical core 8.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of atmosphere dynamical core End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 8.2. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the dynamical core of the model. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.timestepping_type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Adams-Bashforth" # "explicit" # "implicit" # "semi-implicit" # "leap frog" # "multi-step" # "Runge Kutta fifth order" # "Runge Kutta second order" # "Runge Kutta third order" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 8.3. Timestepping Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Timestepping framework type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.prognostic_variables') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "surface pressure" # "wind components" # "divergence/curl" # "temperature" # "potential temperature" # "total water" # "water vapour" # "water liquid" # "water ice" # "total water moments" # "clouds" # "radiation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 8.4. Prognostic Variables Is Required: TRUE    Type: ENUM    Cardinality: 1.N List of the model prognostic variables End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.top_boundary.top_boundary_condition') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "sponge layer" # "radiation boundary condition" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 9. Dynamical Core --> Top Boundary Type of boundary layer at the top of the model 9.1. Top Boundary Condition Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Top boundary condition End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.top_boundary.top_heat') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 9.2. Top Heat Is Required: TRUE    Type: STRING    Cardinality: 1.1 Top boundary heat treatment End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.top_boundary.top_wind') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 9.3. Top Wind Is Required: TRUE    Type: STRING    Cardinality: 1.1 Top boundary wind treatment End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.lateral_boundary.condition') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "sponge layer" # "radiation boundary condition" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 10. Dynamical Core --> Lateral Boundary Type of lateral boundary condition (if the model is a regional model) 10.1. Condition Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Type of lateral boundary condition End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.diffusion_horizontal.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 11. Dynamical Core --> Diffusion Horizontal Horizontal diffusion scheme 11.1. Scheme Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Horizontal diffusion scheme name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.diffusion_horizontal.scheme_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "iterated Laplacian" # "bi-harmonic" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 11.2. Scheme Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Horizontal diffusion scheme method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_tracers.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Heun" # "Roe and VanLeer" # "Roe and Superbee" # "Prather" # "UTOPIA" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 12. Dynamical Core --> Advection Tracers Tracer advection scheme 12.1. Scheme Name Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Tracer advection scheme name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_tracers.scheme_characteristics') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "Eulerian" # "modified Euler" # "Lagrangian" # "semi-Lagrangian" # "cubic semi-Lagrangian" # "quintic semi-Lagrangian" # "mass-conserving" # "finite volume" # "flux-corrected" # "linear" # "quadratic" # "quartic" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 12.2. Scheme Characteristics Is Required: TRUE    Type: ENUM    Cardinality: 1.N Tracer advection scheme characteristics End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_tracers.conserved_quantities') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "dry mass" # "tracer mass" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 12.3. Conserved Quantities Is Required: TRUE    Type: ENUM    Cardinality: 1.N Tracer advection scheme conserved quantities End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_tracers.conservation_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "conservation fixer" # "Priestley algorithm" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 12.4. Conservation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Tracer advection scheme conservation method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_momentum.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "VanLeer" # "Janjic" # "SUPG (Streamline Upwind Petrov-Galerkin)" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 13. Dynamical Core --> Advection Momentum Momentum advection scheme 13.1. Scheme Name Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Momentum advection schemes name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_momentum.scheme_characteristics') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "2nd order" # "4th order" # "cell-centred" # "staggered grid" # "semi-staggered grid" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 13.2. Scheme Characteristics Is Required: TRUE    Type: ENUM    Cardinality: 1.N Momentum advection scheme characteristics End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_momentum.scheme_staggering_type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Arakawa B-grid" # "Arakawa C-grid" # "Arakawa D-grid" # "Arakawa E-grid" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 13.3. Scheme Staggering Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Momentum advection scheme staggering type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_momentum.conserved_quantities') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "Angular momentum" # "Horizontal momentum" # "Enstrophy" # "Mass" # "Total energy" # "Vorticity" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 13.4. Conserved Quantities Is Required: TRUE    Type: ENUM    Cardinality: 1.N Momentum advection scheme conserved quantities End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.dynamical_core.advection_momentum.conservation_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "conservation fixer" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 13.5. Conservation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Momentum advection scheme conservation method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.aerosols') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "sulphate" # "nitrate" # "sea salt" # "dust" # "ice" # "organic" # "BC (black carbon / soot)" # "SOA (secondary organic aerosols)" # "POM (particulate organic matter)" # "polar stratospheric ice" # "NAT (nitric acid trihydrate)" # "NAD (nitric acid dihydrate)" # "STS (supercooled ternary solution aerosol particle)" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 14. Radiation Characteristics of the atmosphere radiation process 14.1. Aerosols Is Required: TRUE    Type: ENUM    Cardinality: 1.N Aerosols whose radiative effect is taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_radiation.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 15. Radiation --> Shortwave Radiation Properties of the shortwave radiation scheme 15.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of shortwave radiation in the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_radiation.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 15.2. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_radiation.spectral_integration') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "wide-band model" # "correlated-k" # "exponential sum fitting" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 15.3. Spectral Integration Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Shortwave radiation scheme spectral integration End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_radiation.transport_calculation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "two-stream" # "layer interaction" # "bulk" # "adaptive" # "multi-stream" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 15.4. Transport Calculation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Shortwave radiation transport calculation methods End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_radiation.spectral_intervals') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 15.5. Spectral Intervals Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Shortwave radiation scheme number of spectral intervals End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_GHG.greenhouse_gas_complexity') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "CO2" # "CH4" # "N2O" # "CFC-11 eq" # "CFC-12 eq" # "HFC-134a eq" # "Explicit ODSs" # "Explicit other fluorinated gases" # "O3" # "H2O" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 16. Radiation --> Shortwave GHG Representation of greenhouse gases in the shortwave radiation scheme 16.1. Greenhouse Gas Complexity Is Required: TRUE    Type: ENUM    Cardinality: 1.N Complexity of greenhouse gases whose shortwave radiative effects are taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_GHG.ODS') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "CFC-12" # "CFC-11" # "CFC-113" # "CFC-114" # "CFC-115" # "HCFC-22" # "HCFC-141b" # "HCFC-142b" # "Halon-1211" # "Halon-1301" # "Halon-2402" # "methyl chloroform" # "carbon tetrachloride" # "methyl chloride" # "methylene chloride" # "chloroform" # "methyl bromide" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 16.2. ODS Is Required: FALSE    Type: ENUM    Cardinality: 0.N Ozone depleting substances whose shortwave radiative effects are explicitly taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_GHG.other_flourinated_gases') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "HFC-134a" # "HFC-23" # "HFC-32" # "HFC-125" # "HFC-143a" # "HFC-152a" # "HFC-227ea" # "HFC-236fa" # "HFC-245fa" # "HFC-365mfc" # "HFC-43-10mee" # "CF4" # "C2F6" # "C3F8" # "C4F10" # "C5F12" # "C6F14" # "C7F16" # "C8F18" # "c-C4F8" # "NF3" # "SF6" # "SO2F2" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 16.3. Other Flourinated Gases Is Required: FALSE    Type: ENUM    Cardinality: 0.N Other flourinated gases whose shortwave radiative effects are explicitly taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_ice.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 17. Radiation --> Shortwave Cloud Ice Shortwave radiative properties of ice crystals in clouds 17.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General shortwave radiative interactions with cloud ice crystals End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_ice.physical_representation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "bi-modal size distribution" # "ensemble of ice crystals" # "mean projected area" # "ice water path" # "crystal asymmetry" # "crystal aspect ratio" # "effective crystal radius" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 17.2. Physical Representation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of cloud ice crystals in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_ice.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "T-matrix" # "geometric optics" # "finite difference time domain (FDTD)" # "Mie theory" # "anomalous diffraction approximation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 17.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to cloud ice crystals in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_liquid.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 18. Radiation --> Shortwave Cloud Liquid Shortwave radiative properties of liquid droplets in clouds 18.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General shortwave radiative interactions with cloud liquid droplets End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_liquid.physical_representation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "cloud droplet number concentration" # "effective cloud droplet radii" # "droplet size distribution" # "liquid water path" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 18.2. Physical Representation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of cloud liquid droplets in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_liquid.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "geometric optics" # "Mie theory" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 18.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to cloud liquid droplets in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_cloud_inhomogeneity.cloud_inhomogeneity') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Monte Carlo Independent Column Approximation" # "Triplecloud" # "analytic" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 19. Radiation --> Shortwave Cloud Inhomogeneity Cloud inhomogeneity in the shortwave radiation scheme 19.1. Cloud Inhomogeneity Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Method for taking into account horizontal cloud inhomogeneity End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_aerosols.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 20. Radiation --> Shortwave Aerosols Shortwave radiative properties of aerosols 20.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General shortwave radiative interactions with aerosols End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_aerosols.physical_representation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "number concentration" # "effective radii" # "size distribution" # "asymmetry" # "aspect ratio" # "mixing state" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 20.2. Physical Representation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of aerosols in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_aerosols.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "T-matrix" # "geometric optics" # "finite difference time domain (FDTD)" # "Mie theory" # "anomalous diffraction approximation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 20.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to aerosols in the shortwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.shortwave_gases.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 21. Radiation --> Shortwave Gases Shortwave radiative properties of gases 21.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General shortwave radiative interactions with gases End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_radiation.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 22. Radiation --> Longwave Radiation Properties of the longwave radiation scheme 22.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of longwave radiation in the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_radiation.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 22.2. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the longwave radiation scheme. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_radiation.spectral_integration') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "wide-band model" # "correlated-k" # "exponential sum fitting" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 22.3. Spectral Integration Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Longwave radiation scheme spectral integration End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_radiation.transport_calculation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "two-stream" # "layer interaction" # "bulk" # "adaptive" # "multi-stream" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 22.4. Transport Calculation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Longwave radiation transport calculation methods End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_radiation.spectral_intervals') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 22.5. Spectral Intervals Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Longwave radiation scheme number of spectral intervals End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_GHG.greenhouse_gas_complexity') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "CO2" # "CH4" # "N2O" # "CFC-11 eq" # "CFC-12 eq" # "HFC-134a eq" # "Explicit ODSs" # "Explicit other fluorinated gases" # "O3" # "H2O" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 23. Radiation --> Longwave GHG Representation of greenhouse gases in the longwave radiation scheme 23.1. Greenhouse Gas Complexity Is Required: TRUE    Type: ENUM    Cardinality: 1.N Complexity of greenhouse gases whose longwave radiative effects are taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_GHG.ODS') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "CFC-12" # "CFC-11" # "CFC-113" # "CFC-114" # "CFC-115" # "HCFC-22" # "HCFC-141b" # "HCFC-142b" # "Halon-1211" # "Halon-1301" # "Halon-2402" # "methyl chloroform" # "carbon tetrachloride" # "methyl chloride" # "methylene chloride" # "chloroform" # "methyl bromide" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 23.2. ODS Is Required: FALSE    Type: ENUM    Cardinality: 0.N Ozone depleting substances whose longwave radiative effects are explicitly taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_GHG.other_flourinated_gases') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "HFC-134a" # "HFC-23" # "HFC-32" # "HFC-125" # "HFC-143a" # "HFC-152a" # "HFC-227ea" # "HFC-236fa" # "HFC-245fa" # "HFC-365mfc" # "HFC-43-10mee" # "CF4" # "C2F6" # "C3F8" # "C4F10" # "C5F12" # "C6F14" # "C7F16" # "C8F18" # "c-C4F8" # "NF3" # "SF6" # "SO2F2" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 23.3. Other Flourinated Gases Is Required: FALSE    Type: ENUM    Cardinality: 0.N Other flourinated gases whose longwave radiative effects are explicitly taken into account in the atmosphere model End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_ice.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 24. Radiation --> Longwave Cloud Ice Longwave radiative properties of ice crystals in clouds 24.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General longwave radiative interactions with cloud ice crystals End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_ice.physical_reprenstation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "bi-modal size distribution" # "ensemble of ice crystals" # "mean projected area" # "ice water path" # "crystal asymmetry" # "crystal aspect ratio" # "effective crystal radius" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 24.2. Physical Reprenstation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of cloud ice crystals in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_ice.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "T-matrix" # "geometric optics" # "finite difference time domain (FDTD)" # "Mie theory" # "anomalous diffraction approximation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 24.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to cloud ice crystals in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_liquid.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 25. Radiation --> Longwave Cloud Liquid Longwave radiative properties of liquid droplets in clouds 25.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General longwave radiative interactions with cloud liquid droplets End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_liquid.physical_representation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "cloud droplet number concentration" # "effective cloud droplet radii" # "droplet size distribution" # "liquid water path" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 25.2. Physical Representation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of cloud liquid droplets in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_liquid.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "geometric optics" # "Mie theory" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 25.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to cloud liquid droplets in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_cloud_inhomogeneity.cloud_inhomogeneity') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Monte Carlo Independent Column Approximation" # "Triplecloud" # "analytic" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 26. Radiation --> Longwave Cloud Inhomogeneity Cloud inhomogeneity in the longwave radiation scheme 26.1. Cloud Inhomogeneity Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Method for taking into account horizontal cloud inhomogeneity End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_aerosols.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 27. Radiation --> Longwave Aerosols Longwave radiative properties of aerosols 27.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General longwave radiative interactions with aerosols End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_aerosols.physical_representation') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "number concentration" # "effective radii" # "size distribution" # "asymmetry" # "aspect ratio" # "mixing state" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 27.2. Physical Representation Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical representation of aerosols in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_aerosols.optical_methods') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "T-matrix" # "geometric optics" # "finite difference time domain (FDTD)" # "Mie theory" # "anomalous diffraction approximation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 27.3. Optical Methods Is Required: TRUE    Type: ENUM    Cardinality: 1.N Optical methods applicable to aerosols in the longwave radiation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.radiation.longwave_gases.general_interactions') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "scattering" # "emission/absorption" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 28. Radiation --> Longwave Gases Longwave radiative properties of gases 28.1. General Interactions Is Required: TRUE    Type: ENUM    Cardinality: 1.N General longwave radiative interactions with gases End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 29. Turbulence Convection Atmosphere Convective Turbulence and Clouds 29.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of atmosphere convection and turbulence End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.boundary_layer_turbulence.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Mellor-Yamada" # "Holtslag-Boville" # "EDMF" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 30. Turbulence Convection --> Boundary Layer Turbulence Properties of the boundary layer turbulence scheme 30.1. Scheme Name Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Boundary layer turbulence scheme name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.boundary_layer_turbulence.scheme_type') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "TKE prognostic" # "TKE diagnostic" # "TKE coupled with water" # "vertical profile of Kz" # "non-local diffusion" # "Monin-Obukhov similarity" # "Coastal Buddy Scheme" # "Coupled with convection" # "Coupled with gravity waves" # "Depth capped at cloud base" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 30.2. Scheme Type Is Required: TRUE    Type: ENUM    Cardinality: 1.N Boundary layer turbulence scheme type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.boundary_layer_turbulence.closure_order') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 30.3. Closure Order Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Boundary layer turbulence scheme closure order End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.boundary_layer_turbulence.counter_gradient') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 30.4. Counter Gradient Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Uses boundary layer turbulence scheme counter gradient End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.deep_convection.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 31. Turbulence Convection --> Deep Convection Properties of the deep convection scheme 31.1. Scheme Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Deep convection scheme name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.deep_convection.scheme_type') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "mass-flux" # "adjustment" # "plume ensemble" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 31.2. Scheme Type Is Required: TRUE    Type: ENUM    Cardinality: 1.N Deep convection scheme type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.deep_convection.scheme_method') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "CAPE" # "bulk" # "ensemble" # "CAPE/WFN based" # "TKE/CIN based" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 31.3. Scheme Method Is Required: TRUE    Type: ENUM    Cardinality: 1.N Deep convection scheme method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.deep_convection.processes') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "vertical momentum transport" # "convective momentum transport" # "entrainment" # "detrainment" # "penetrative convection" # "updrafts" # "downdrafts" # "radiative effect of anvils" # "re-evaporation of convective precipitation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 31.4. Processes Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical processes taken into account in the parameterisation of deep convection End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.deep_convection.microphysics') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "tuning parameter based" # "single moment" # "two moment" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 31.5. Microphysics Is Required: FALSE    Type: ENUM    Cardinality: 0.N Microphysics scheme for deep convection. Microphysical processes directly control the amount of detrainment of cloud hydrometeor and water vapor from updrafts End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.shallow_convection.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 32. Turbulence Convection --> Shallow Convection Properties of the shallow convection scheme 32.1. Scheme Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Shallow convection scheme name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.shallow_convection.scheme_type') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "mass-flux" # "cumulus-capped boundary layer" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 32.2. Scheme Type Is Required: TRUE    Type: ENUM    Cardinality: 1.N shallow convection scheme type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.shallow_convection.scheme_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "same as deep (unified)" # "included in boundary layer turbulence" # "separate diagnosis" # TODO - please enter value(s) Explanation: 32.3. Scheme Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 shallow convection scheme method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.shallow_convection.processes') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "convective momentum transport" # "entrainment" # "detrainment" # "penetrative convection" # "re-evaporation of convective precipitation" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 32.4. Processes Is Required: TRUE    Type: ENUM    Cardinality: 1.N Physical processes taken into account in the parameterisation of shallow convection End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.turbulence_convection.shallow_convection.microphysics') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "tuning parameter based" # "single moment" # "two moment" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 32.5. Microphysics Is Required: FALSE    Type: ENUM    Cardinality: 0.N Microphysics scheme for shallow convection End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.microphysics_precipitation.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 33. Microphysics Precipitation Large Scale Cloud Microphysics and Precipitation 33.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of large scale cloud microphysics and precipitation End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.microphysics_precipitation.large_scale_precipitation.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 34. Microphysics Precipitation --> Large Scale Precipitation Properties of the large scale precipitation scheme 34.1. Scheme Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name of the large scale precipitation parameterisation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.microphysics_precipitation.large_scale_precipitation.hydrometeors') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "liquid rain" # "snow" # "hail" # "graupel" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 34.2. Hydrometeors Is Required: TRUE    Type: ENUM    Cardinality: 1.N Precipitating hydrometeors taken into account in the large scale precipitation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.microphysics_precipitation.large_scale_cloud_microphysics.scheme_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 35. Microphysics Precipitation --> Large Scale Cloud Microphysics Properties of the large scale cloud microphysics scheme 35.1. Scheme Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name of the microphysics parameterisation scheme used for large scale clouds. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.microphysics_precipitation.large_scale_cloud_microphysics.processes') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "mixed phase" # "cloud droplets" # "cloud ice" # "ice nucleation" # "water vapour deposition" # "effect of raindrops" # "effect of snow" # "effect of graupel" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 35.2. Processes Is Required: TRUE    Type: ENUM    Cardinality: 1.N Large scale cloud microphysics processes End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 36. Cloud Scheme Characteristics of the cloud scheme 36.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of the atmosphere cloud scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 36.2. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the cloud scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.atmos_coupling') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "atmosphere_radiation" # "atmosphere_microphysics_precipitation" # "atmosphere_turbulence_convection" # "atmosphere_gravity_waves" # "atmosphere_solar" # "atmosphere_volcano" # "atmosphere_cloud_simulator" # TODO - please enter value(s) Explanation: 36.3. Atmos Coupling Is Required: FALSE    Type: ENUM    Cardinality: 0.N Atmosphere components that are linked to the cloud scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.uses_separate_treatment') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 36.4. Uses Separate Treatment Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Different cloud schemes for the different types of clouds (convective, stratiform and boundary layer) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.processes') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "entrainment" # "detrainment" # "bulk cloud" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 36.5. Processes Is Required: TRUE    Type: ENUM    Cardinality: 1.N Processes included in the cloud scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.prognostic_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 36.6. Prognostic Scheme Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Is the cloud scheme a prognostic scheme? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.diagnostic_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 36.7. Diagnostic Scheme Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Is the cloud scheme a diagnostic scheme? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.prognostic_variables') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "cloud amount" # "liquid" # "ice" # "rain" # "snow" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 36.8. Prognostic Variables Is Required: FALSE    Type: ENUM    Cardinality: 0.N List the prognostic variables used by the cloud scheme, if applicable. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.optical_cloud_properties.cloud_overlap_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "random" # "maximum" # "maximum-random" # "exponential" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 37. Cloud Scheme --> Optical Cloud Properties Optical cloud properties 37.1. Cloud Overlap Method Is Required: FALSE    Type: ENUM    Cardinality: 0.1 Method for taking into account overlapping of cloud layers End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.optical_cloud_properties.cloud_inhomogeneity') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 37.2. Cloud Inhomogeneity Is Required: FALSE    Type: STRING    Cardinality: 0.1 Method for taking into account cloud inhomogeneity End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_water_distribution.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "prognostic" # "diagnostic" # TODO - please enter value(s) Explanation: 38. Cloud Scheme --> Sub Grid Scale Water Distribution Sub-grid scale water distribution 38.1. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Sub-grid scale water distribution type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_water_distribution.function_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 38.2. Function Name Is Required: TRUE    Type: STRING    Cardinality: 1.1 Sub-grid scale water distribution function name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_water_distribution.function_order') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 38.3. Function Order Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Sub-grid scale water distribution function type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_water_distribution.convection_coupling') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "coupled with deep" # "coupled with shallow" # "not coupled with convection" # TODO - please enter value(s) Explanation: 38.4. Convection Coupling Is Required: TRUE    Type: ENUM    Cardinality: 1.N Sub-grid scale water distribution coupling with convection End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_ice_distribution.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "prognostic" # "diagnostic" # TODO - please enter value(s) Explanation: 39. Cloud Scheme --> Sub Grid Scale Ice Distribution Sub-grid scale ice distribution 39.1. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Sub-grid scale ice distribution type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_ice_distribution.function_name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 39.2. Function Name Is Required: TRUE    Type: STRING    Cardinality: 1.1 Sub-grid scale ice distribution function name End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_ice_distribution.function_order') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 39.3. Function Order Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Sub-grid scale ice distribution function type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.cloud_scheme.sub_grid_scale_ice_distribution.convection_coupling') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "coupled with deep" # "coupled with shallow" # "not coupled with convection" # TODO - please enter value(s) Explanation: 39.4. Convection Coupling Is Required: TRUE    Type: ENUM    Cardinality: 1.N Sub-grid scale ice distribution coupling with convection End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 40. Observation Simulation Characteristics of observation simulation 40.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of observation simulator characteristics End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.isscp_attributes.top_height_estimation_method') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "no adjustment" # "IR brightness" # "visible optical depth" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 41. Observation Simulation --> Isscp Attributes ISSCP Characteristics 41.1. Top Height Estimation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.N Cloud simulator ISSCP top height estimation methodUo End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.isscp_attributes.top_height_direction') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "lowest altitude level" # "highest altitude level" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 41.2. Top Height Direction Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Cloud simulator ISSCP top height direction End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.cosp_attributes.run_configuration') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Inline" # "Offline" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 42. Observation Simulation --> Cosp Attributes CFMIP Observational Simulator Package attributes 42.1. Run Configuration Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Cloud simulator COSP run configuration End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.cosp_attributes.number_of_grid_points') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 42.2. Number Of Grid Points Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Cloud simulator COSP number of grid points End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.cosp_attributes.number_of_sub_columns') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 42.3. Number Of Sub Columns Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Cloud simulator COSP number of sub-cloumns used to simulate sub-grid variability End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.cosp_attributes.number_of_levels') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 42.4. Number Of Levels Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Cloud simulator COSP number of levels End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.radar_inputs.frequency') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 43. Observation Simulation --> Radar Inputs Characteristics of the cloud radar simulator 43.1. Frequency Is Required: TRUE    Type: FLOAT    Cardinality: 1.1 Cloud simulator radar frequency (Hz) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.radar_inputs.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "surface" # "space borne" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 43.2. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Cloud simulator radar type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.radar_inputs.gas_absorption') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 43.3. Gas Absorption Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Cloud simulator radar uses gas absorption End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.radar_inputs.effective_radius') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 43.4. Effective Radius Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Cloud simulator radar uses effective radius End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.lidar_inputs.ice_types') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "ice spheres" # "ice non-spherical" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 44. Observation Simulation --> Lidar Inputs Characteristics of the cloud lidar simulator 44.1. Ice Types Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Cloud simulator lidar ice type End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.observation_simulation.lidar_inputs.overlap') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "max" # "random" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 44.2. Overlap Is Required: TRUE    Type: ENUM    Cardinality: 1.N Cloud simulator lidar overlap End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 45. Gravity Waves Characteristics of the parameterised gravity waves in the atmosphere, whether from orography or other sources. 45.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of gravity wave parameterisation in the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.sponge_layer') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Rayleigh friction" # "Diffusive sponge layer" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 45.2. Sponge Layer Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Sponge layer in the upper levels in order to avoid gravity wave reflection at the top. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.background') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "continuous spectrum" # "discrete spectrum" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 45.3. Background Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Background wave distribution End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.subgrid_scale_orography') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "effect on drag" # "effect on lifting" # "enhanced topography" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 45.4. Subgrid Scale Orography Is Required: TRUE    Type: ENUM    Cardinality: 1.N Subgrid scale orography effects taken into account. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.orographic_gravity_waves.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 46. Gravity Waves --> Orographic Gravity Waves Gravity waves generated due to the presence of orography 46.1. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the orographic gravity wave scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.orographic_gravity_waves.source_mechanisms') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "linear mountain waves" # "hydraulic jump" # "envelope orography" # "low level flow blocking" # "statistical sub-grid scale variance" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 46.2. Source Mechanisms Is Required: TRUE    Type: ENUM    Cardinality: 1.N Orographic gravity wave source mechanisms End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.orographic_gravity_waves.calculation_method') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "non-linear calculation" # "more than two cardinal directions" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 46.3. Calculation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.N Orographic gravity wave calculation method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.orographic_gravity_waves.propagation_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "linear theory" # "non-linear theory" # "includes boundary layer ducting" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 46.4. Propagation Scheme Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Orographic gravity wave propogation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.orographic_gravity_waves.dissipation_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "total wave" # "single wave" # "spectral" # "linear" # "wave saturation vs Richardson number" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 46.5. Dissipation Scheme Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Orographic gravity wave dissipation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.non_orographic_gravity_waves.name') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 47. Gravity Waves --> Non Orographic Gravity Waves Gravity waves generated by non-orographic processes. 47.1. Name Is Required: FALSE    Type: STRING    Cardinality: 0.1 Commonly used name for the non-orographic gravity wave scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.non_orographic_gravity_waves.source_mechanisms') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "convection" # "precipitation" # "background spectrum" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 47.2. Source Mechanisms Is Required: TRUE    Type: ENUM    Cardinality: 1.N Non-orographic gravity wave source mechanisms End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.non_orographic_gravity_waves.calculation_method') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "spatially dependent" # "temporally dependent" # TODO - please enter value(s) Explanation: 47.3. Calculation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.N Non-orographic gravity wave calculation method End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.non_orographic_gravity_waves.propagation_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "linear theory" # "non-linear theory" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 47.4. Propagation Scheme Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Non-orographic gravity wave propogation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.gravity_waves.non_orographic_gravity_waves.dissipation_scheme') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "total wave" # "single wave" # "spectral" # "linear" # "wave saturation vs Richardson number" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 47.5. Dissipation Scheme Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Non-orographic gravity wave dissipation scheme End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 48. Solar Top of atmosphere solar insolation characteristics 48.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of solar insolation of the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.solar_pathways.pathways') # PROPERTY VALUE(S): # Set as follows: DOC.set_value("value") # Valid Choices: # "SW radiation" # "precipitating energetic particles" # "cosmic rays" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 49. Solar --> Solar Pathways Pathways for solar forcing of the atmosphere 49.1. Pathways Is Required: TRUE    Type: ENUM    Cardinality: 1.N Pathways for the solar forcing of the atmosphere model domain End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.solar_constant.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "fixed" # "transient" # TODO - please enter value(s) Explanation: 50. Solar --> Solar Constant Solar constant and top of atmosphere insolation characteristics 50.1. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Time adaptation of the solar constant. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.solar_constant.fixed_value') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 50.2. Fixed Value Is Required: FALSE    Type: FLOAT    Cardinality: 0.1 If the solar constant is fixed, enter the value of the solar constant (W m-2). End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.solar_constant.transient_characteristics') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 50.3. Transient Characteristics Is Required: TRUE    Type: STRING    Cardinality: 1.1 solar constant transient characteristics (W m-2) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.orbital_parameters.type') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "fixed" # "transient" # TODO - please enter value(s) Explanation: 51. Solar --> Orbital Parameters Orbital parameters and top of atmosphere insolation characteristics 51.1. Type Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Time adaptation of orbital parameters End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.orbital_parameters.fixed_reference_date') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # TODO - please enter value(s) Explanation: 51.2. Fixed Reference Date Is Required: TRUE    Type: INTEGER    Cardinality: 1.1 Reference date for fixed orbital parameters (yyyy) End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.orbital_parameters.transient_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 51.3. Transient Method Is Required: TRUE    Type: STRING    Cardinality: 1.1 Description of transient orbital parameters End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.orbital_parameters.computation_method') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "Berger 1978" # "Laskar 2004" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 51.4. Computation Method Is Required: TRUE    Type: ENUM    Cardinality: 1.1 Method used for computing orbital parameters. End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.solar.insolation_ozone.solar_ozone_impact') # PROPERTY VALUE: # Set as follows: DOC.set_value(value) # Valid Choices: # True # False # TODO - please enter value(s) Explanation: 52. Solar --> Insolation Ozone Impact of solar insolation on stratospheric ozone 52.1. Solar Ozone Impact Is Required: TRUE    Type: BOOLEAN    Cardinality: 1.1 Does top of atmosphere insolation impact on stratospheric ozone? End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.volcanos.overview') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # TODO - please enter value(s) Explanation: 53. Volcanos Characteristics of the implementation of volcanoes 53.1. Overview Is Required: TRUE    Type: STRING    Cardinality: 1.1 Overview description of the implementation of volcanic effects in the atmosphere End of explanation # PROPERTY ID - DO NOT EDIT ! DOC.set_id('cmip6.atmos.volcanos.volcanoes_treatment.volcanoes_implementation') # PROPERTY VALUE: # Set as follows: DOC.set_value("value") # Valid Choices: # "high frequency solar constant anomaly" # "stratospheric aerosols optical thickness" # "Other: [Please specify]" # TODO - please enter value(s) Explanation: 54. Volcanos --> Volcanoes Treatment Treatment of volcanoes in the atmosphere 54.1. Volcanoes Implementation Is Required: TRUE    Type: ENUM    Cardinality: 1.1 How volcanic effects are modeled in the atmosphere. End of explanation