public interface EntityEquipment
| Modifier and Type | Method and Description |
|---|---|
void |
clear()
Clears the entity of all armor and held items
|
@NotNull ItemStack[] |
getArmorContents()
Gets a copy of all worn armor
|
@Nullable ItemStack |
getBoots()
Gets a copy of the boots currently being worn by the entity
|
float |
getBootsDropChance()
Gets the chance of the boots being dropped upon this creature's death.
|
@Nullable ItemStack |
getChestplate()
Gets a copy of the chest plate currently being worn by the entity
|
float |
getChestplateDropChance()
Gets the chance of the chest plate being dropped upon this creature's
death.
|
float |
getDropChance(@NotNull EquipmentSlot slot)
Gets the drop chance of specified slot.
|
@Nullable ItemStack |
getHelmet()
Gets a copy of the helmet currently being worn by the entity
|
float |
getHelmetDropChance()
Gets the chance of the helmet being dropped upon this creature's death.
|
@Nullable Entity |
getHolder()
Get the entity this EntityEquipment belongs to
|
@NotNull ItemStack |
getItem(@NotNull EquipmentSlot slot)
Gets the ItemStack at the given equipment slot in the inventory.
|
@NotNull ItemStack |
getItemInHand()
Deprecated.
entities can duel wield now use the methods for the
specific hand instead
|
float |
getItemInHandDropChance()
Deprecated.
entities can duel wield now use the methods for the specific
hand instead
|
@NotNull ItemStack |
getItemInMainHand()
Gets a copy of the item the entity is currently holding
in their main hand.
|
float |
getItemInMainHandDropChance()
Gets the chance of the main hand item being dropped upon this creature's
death.
|
@NotNull ItemStack |
getItemInOffHand()
Gets a copy of the item the entity is currently holding
in their off hand.
|
float |
getItemInOffHandDropChance()
Gets the chance of the off hand item being dropped upon this creature's
death.
|
@Nullable ItemStack |
getLeggings()
Gets a copy of the leggings currently being worn by the entity
|
float |
getLeggingsDropChance()
Gets the chance of the leggings being dropped upon this creature's
death.
|
void |
setArmorContents(@NotNull ItemStack[] items)
Sets the entities armor to the provided array of ItemStacks
|
void |
setBoots(@Nullable ItemStack boots)
Sets the boots worn by the entity
|
void |
setBoots(@Nullable ItemStack boots,
boolean silent)
Sets the boots worn by the entity
|
void |
setBootsDropChance(float chance)
Sets the chance of the boots being dropped upon this creature's death.
|
void |
setChestplate(@Nullable ItemStack chestplate)
Sets the chest plate worn by the entity
|
void |
setChestplate(@Nullable ItemStack chestplate,
boolean silent)
Sets the chest plate worn by the entity
|
void |
setChestplateDropChance(float chance)
Sets the chance of the chest plate being dropped upon this creature's
death.
|
void |
setDropChance(@NotNull EquipmentSlot slot,
float chance)
Sets the drop chance of the specified slot.
|
void |
setHelmet(@Nullable ItemStack helmet)
Sets the helmet worn by the entity
|
void |
setHelmet(@Nullable ItemStack helmet,
boolean silent)
Sets the helmet worn by the entity
|
void |
setHelmetDropChance(float chance)
Sets the chance of the helmet being dropped upon this creature's death.
|
void |
setItem(@NotNull EquipmentSlot slot,
@Nullable ItemStack item)
Stores the ItemStack at the given equipment slot in the inventory.
|
void |
setItem(@NotNull EquipmentSlot slot,
@Nullable ItemStack item,
boolean silent)
Stores the ItemStack at the given equipment slot in the inventory.
|
void |
setItemInHand(@Nullable ItemStack stack)
Deprecated.
entities can duel wield now use the methods for the
specific hand instead
|
void |
setItemInHandDropChance(float chance)
Deprecated.
entities can duel wield now use the methods for the specific
hand instead
|
void |
setItemInMainHand(@Nullable ItemStack item)
Sets the item the entity is holding in their main hand.
|
void |
setItemInMainHand(@Nullable ItemStack item,
boolean silent)
Sets the item the entity is holding in their main hand.
|
void |
setItemInMainHandDropChance(float chance)
Sets the chance of the item this creature is currently holding in their
main hand being dropped upon this creature's death.
|
void |
setItemInOffHand(@Nullable ItemStack item)
Sets the item the entity is holding in their off hand.
|
void |
setItemInOffHand(@Nullable ItemStack item,
boolean silent)
Sets the item the entity is holding in their off hand.
|
void |
setItemInOffHandDropChance(float chance)
Sets the chance of the off hand item being dropped upon this creature's
death.
|
void |
setLeggings(@Nullable ItemStack leggings)
Sets the leggings worn by the entity
|
void |
setLeggings(@Nullable ItemStack leggings,
boolean silent)
Sets the leggings worn by the entity
|
void |
setLeggingsDropChance(float chance)
Sets the chance of the leggings being dropped upon this creature's
death.
|
void setItem(@NotNull @NotNull EquipmentSlot slot, @Nullable @Nullable ItemStack item)
slot
- the slot to put the ItemStackitem
- the ItemStack to setvoid setItem(@NotNull @NotNull EquipmentSlot slot, @Nullable @Nullable ItemStack item, boolean silent)
slot
- the slot to put the ItemStackitem
- the ItemStack to setsilent
- whether or not the equip sound should be silenced@NotNull @NotNull ItemStack getItem(@NotNull @NotNull EquipmentSlot slot)
slot
- the slot to get the ItemStack@NotNull @NotNull ItemStack getItemInMainHand()
void setItemInMainHand(@Nullable @Nullable ItemStack item)
item
- The item to put into the entities handvoid setItemInMainHand(@Nullable @Nullable ItemStack item, boolean silent)
item
- The item to put into the entities handsilent
- whether or not the equip sound should be silenced@NotNull @NotNull ItemStack getItemInOffHand()
void setItemInOffHand(@Nullable @Nullable ItemStack item)
item
- The item to put into the entities handvoid setItemInOffHand(@Nullable @Nullable ItemStack item, boolean silent)
item
- The item to put into the entities handsilent
- whether or not the equip sound should be silenced@Deprecated @NotNull @NotNull ItemStack getItemInHand()
getItemInMainHand()
,
getItemInOffHand()
@Deprecated void setItemInHand(@Nullable @Nullable ItemStack stack)
stack
- The item to put into the entities handsetItemInMainHand(ItemStack)
,
setItemInOffHand(ItemStack)
@Nullable @Nullable ItemStack getHelmet()
void setHelmet(@Nullable @Nullable ItemStack helmet)
helmet
- The helmet to put on the entityvoid setHelmet(@Nullable @Nullable ItemStack helmet, boolean silent)
helmet
- The helmet to put on the entitysilent
- whether or not the equip sound should be silenced@Nullable @Nullable ItemStack getChestplate()
void setChestplate(@Nullable @Nullable ItemStack chestplate)
chestplate
- The chest plate to put on the entityvoid setChestplate(@Nullable @Nullable ItemStack chestplate, boolean silent)
chestplate
- The chest plate to put on the entitysilent
- whether or not the equip sound should be silenced@Nullable @Nullable ItemStack getLeggings()
void setLeggings(@Nullable @Nullable ItemStack leggings)
leggings
- The leggings to put on the entityvoid setLeggings(@Nullable @Nullable ItemStack leggings, boolean silent)
leggings
- The leggings to put on the entitysilent
- whether or not the equip sound should be silenced@Nullable @Nullable ItemStack getBoots()
void setBoots(@Nullable @Nullable ItemStack boots)
boots
- The boots to put on the entityvoid setBoots(@Nullable @Nullable ItemStack boots, boolean silent)
boots
- The boots to put on the entitysilent
- whether or not the equip sound should be silenced@NotNull @NotNull ItemStack[] getArmorContents()
void setArmorContents(@NotNull @NotNull ItemStack[] items)
items
- The items to set the armor as. Individual items may be null.void clear()
@Deprecated float getItemInHandDropChance()
getItemInMainHandDropChance()
,
getItemInOffHandDropChance()
@Deprecated void setItemInHandDropChance(float chance)
chance
- drop chancesetItemInMainHandDropChance(float)
,
setItemInOffHandDropChance(float)
float getItemInMainHandDropChance()
void setItemInMainHandDropChance(float chance)
chance
- the chance of the main hand item being droppedUnsupportedOperationException
- when called on playersfloat getItemInOffHandDropChance()
void setItemInOffHandDropChance(float chance)
chance
- the chance of off hand item being droppedUnsupportedOperationException
- when called on playersfloat getHelmetDropChance()
void setHelmetDropChance(float chance)
chance
- of the helmet being droppedUnsupportedOperationException
- when called on playersfloat getChestplateDropChance()
void setChestplateDropChance(float chance)
chance
- of the chest plate being droppedUnsupportedOperationException
- when called on playersfloat getLeggingsDropChance()
void setLeggingsDropChance(float chance)
chance
- chance of the leggings being droppedUnsupportedOperationException
- when called on playersfloat getBootsDropChance()
void setBootsDropChance(float chance)
chance
- of the boots being droppedUnsupportedOperationException
- when called on players@Nullable @Nullable Entity getHolder()
float getDropChance(@NotNull @NotNull EquipmentSlot slot)
slot
- the slot to get the drop chance ofvoid setDropChance(@NotNull @NotNull EquipmentSlot slot, float chance)
slot
- the slot to set the drop chance ofchance
- the drop chance for the slotUnsupportedOperationException
- when called on playersCopyright © 2021. All rights reserved.


Crux Frequently Asked Questions
- What is the difference between Tide and Comet?
-
Tide converts your FASTA file to an index (either as part
of
tide-search
or by usingtide-index
), whereas Comet does searching directly from the FASTA file. The indexing step allows Tide to pre-compute many parts of the search procedure, thereby making the search faster. - For each match, Comet reports the total number of candidate peptides, whereas Tide reports the number of distinct candidate peptides.
-
Comet provides an option to report an E-value in addition to the raw
XCorr score, whereas Tide provides options to report a variety of
different types of scores. The methods for computing Tide's
various scores are described in the documentation
for
tide-index
. - Some options are available only in Comet (various options related to different types of theoretical fragment ions, max_fragment_charge, nucleotide_reading_frame, etc.) whereas others are only available in Tide (e.g., keep-terminal-aminos).
- What operating systems does Crux work with?
- When I try to run Crux on my Linux system I get error messages like:
/tmp/crux: /usr/lib64/libstdc++.so.6: version `CXXABI_1.3.8' not found (required by /tmp/crux) /tmp/crux: /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.20' not found (required by /tmp/crux) /tmp/crux: /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by /tmp/crux)p
Crux depends on the C and C++ runtime libraries; however, newer versions of the runtime libraries are not backwards compatible with older versions. We build the Linux binary distributions for Crux using GCC 4.9. If your Linux system dates from before GCC 4.9 was available, then it may have versions of the runtime library that are incompatible with the Crux binary distribution. In this case, you might consider updating your operating system. Alternatively, you can build Crux from the source code distribution. To build Crux from source you'll ned to install the C/C++ development tools, and CMake. This can conveniently be done usingyum
sudo su - yum group install "Development Tools" yum install cmake
Then follow the instructions in the in the installation tutorial.
- How does Crux compute the masses of peptides and peptide fragments?
-
Each amino acid can be characterized either by its monoisotopic mass,
which is the mass of the most abundant isotopic form of that amino acid,
or the average mass, which is a weighted average of the masses of all
the isotopic forms. By default, Crux uses average mass to calculate
peptide masses, though this behavior can be controlled by the
isotopic-mass
option totide-index
and themass_type_parent
option tocomet
. For fragments,tide-search
always uses the monoisotopic mass, whereascomet
allows selection viamass_type_fragment
. - The neutral mass of a peptide is not the sum of the masses of its amino acids. The N-terminus and C-terminus of the peptide together contribute an additional water molecule, whose mass is either 18.010564684 Da (monoisotopic) or 18.0153 Da (average).
- A charged peptide has an additional approximately 1 Da mass for each charge, corresponding to the mass of a hydrogen atom. The exact mass to be added depends on whether we are using the monoisotopic mass (1.007825035) or average mass (1.00794).
- When a peptide fragments, each b-ion will have a mass equal to the sum of its amino acids plus one hydrogen for each charge on the fragment, while each y-ion will have a mass equal to the sum of its amino acids plus water plus one hydrogen for each charge on the fragment.
-
By default, both Tide and Comet add a static modification of
57.021464 Da to all cysteines. This is because in most protein
preparation protocols the peptides are alkylated with iodoacetamide,
resulting in carbamidomethylation of cysteine. The alkylation step
prevents the reformation of disulfide bonds. Other alykylation
reagents may be used, in which case the appropriate mass shift can be
specified with the
C=[mass]
option totide-index
or theadd_C_cysteine
option tocomet
. - How does Crux assign fragment masses to bins prior to computing the XCorr score?
-
How can I use the average target-decoy competition (aTDC)
procedure described in this paper?
Uri Keich, Kaipo Tamura, and William Stafford Noble. "Averaging strategy to reduce variability in target-decoy estimates of false discovery rate." Journal of Proteome Research, 18(2):585-593, 2019.
-
For what settings of the score-function and mz-bin-width parameter
can I set exact-p-value=T?
- When the combined p-value score function is used (
--score-function=both
),--mz-bin-width=1.0005079
and--exact-p-value=T
. - When the XCorr score function is used (
--score-function=xcorr
),--exact-p-value
can only be set to true when--mz-bin-width=1.0005079
. - When the residue-evidence score function is used (
--score-function=residue-evidence
),--exact-p-value
can only be set to true when--mz-bin-width=1.0005079
. Note that high-resolution information in the residue-evidence score function is captured by--fragment-tolerance
.
- When the combined p-value score function is used (
- How does Crux estimate the possible charge states of the peptides when the information is not provided within the spectra file?
- How does Crux create peptides from the given set of proteins in the database?
- How does Crux select candidate peptides from the database?
-
If the
precursor-window-type
is set tomz
, then the window is calculated as spectrum precursor m/z ±precursor-window
and the resulting range is converted to mass using the charge state with the formula:
Mass=m/z * charge - MASS_PROTON * charge, where MASS_PROTON=1.00727646677 -
If the
precursor-window-type
is set tomass
, then the window is defined as the precursor mass ±precursor-window
. -
If the
precursor-window-type
is set toppm
(parts per million), then the window spans from the precursor mass / (1.0 + window * 1e-6) to precursor mass / (1.0 - window * 1e-6). - How do Tide and Comet handle combinations of static and variable modifications, as well as terminal modifications?
- How does Tide handle peptide and protein terminal modifications?
- What happens if I decrease the size of the precursor window during searching?
- How can I search my isotopically labeled data with Tide or Comet?
- How can I contribute to Crux?
- Where does the name "Crux" come from?
The differences are as follows:
Overall, for a given set of spectra, the XCorr scores computed by Comet and by Tide should be quite similar to one another, assuming that the various search parameters are set similarly between the two algorithms. Below is a table summarizing the correspondence between the two sets of parameters. The specified values will yield nearly identical XCorr scores from the two search engines.
| Tide parameter | Tide value | Comet parameter | Comet value |
| enzyme | trypsin | search_enzyme_number | 1 |
| digestion | full-digest | num_enzyme_termini | 2 |
| missed-cleavages | 0 | allowed_missed_cleavage | 0 |
| min-peaks | 10 | minimum_peaks | 10 |
| precursor-window | 3 | peptide_mass_tolerance | 3 |
| precursor-window-type | mass | peptide_mass_units | 0 |
| fragment-mass | mono | mass_type_fragment | 1 |
| decoy-format | peptide-reverse | N/A | |
| keep-terminal-aminos | C | N/A | |
| concat | T | decoy_search | 1 |
| top-match | 5 | num_results, num_output_lines | 6, 5 |
| remove-precursor-peak | T | remove_precursor_peak | 1 |
| remove-precursor-tolerance | 15 | remove_precursor_tolerance | 15 |
| use-flanking-peaks | F | theoretical_fragment_ions | 1 |
| use-neutral-loss-peaks | F | use_NL_ions | F |
| mz-bin-width | 1.0005079 | fragment_bin_tol | 1.0005079 |
| mz-bin-offset | 0.4 | fragment_bin_offset | 0.4 |
| min-mass, max-mass | 200, 7200 | digest_mass_range | 200 7200 |
| N/A | max_fragment_charge | 2 |
Here is a scatter plot of XCorr scores from a search run with the parameters listed above:
Crux is written in C++, so in principle it should work on virtually any modern operating system. We provide pre-compiled binaries for Linux, MacOS and Windows.
The XCorr score is essentially a dot product between a preprocessed
form of the observed spectrum and the theoretical spectrum derived
from the candidate peptide. In order to compute this dot product, the
masses of the fragments in both spectra are assigned to discrete mass
bins. This can be viewed as a form of rounding, but with more control
over the discrete masses. Two parameters, mz-bin-width
and
mz-bin-offset
, control the size and location of the bins,
and are used to convert fragment masses according to this formula:
binned mass = floor( ( original mass / bin-width
) + 1.0 - bin-offset
)
The default values bin-width
=0.02
and bin-offset
=0.40 are suitable for most high-resolution
datasets.
When you build your peptide index using tide-index, you have to specify the number of decoy databases to include and you have to set allow-dups to be T. It's also important that you leave the decoy-format option at its default value of shuffle, since if you reverse the peptides then all of the databases would be identical. For example, to build an index with five decoys per target from a fasta file called
human.fasta
, you could do this:crux tide-index --num-decoys-per-target 5 --allow-dups T human.fasta human
Also, when you search a file of spectra (
HepG2_f4.mzML
)
using the human
index, you must specify concat=F:crux tide-search --use-tailor-calibration T --concat F HepG2_f4.mzML human
This command stores the search results in the default output directory (
crux-output
) in files
called tide-search.target.txt
and tide-search.decoy.txt
. Notably, the decoy file will
contain five times as many PSMs as the target file, with a column
called "decoy index" to indicate which database the decoy comes from.
Finally, you can run aTDC by calling assign-confidence
.
This command will use the "decoy index" column to do the necessary
averaging over the decoy databases:crux assign-confidence --score "tailor score" crux-output/tide-search.target.txt
The final results are stored in a file called
crux-output/assign-confidence.target.psms.txt
.
Crux calculates the ratio of two values: (1) the sum of the intensities from the peaks in the fragmentation spectrum whose m/z is greater than the precursor m/z versus (2) the sum of the peaks whose m/z is smaller than the precursor. If this ratio is greater than or equal to a calculated threshold based upon the location of the precursor m/z and the max m/z in the spectrum, Crux then assigns both +2 and +3 as possible charge states to the spectrum. Otherwise, Crux assigns +1 as the charge state. The algorithm is based upon the observation that fragmentation spectra collected from +1 peptides should have no peaks above the precursor m/z. In contrast, a peptide of charge state greater than +1 can generate fragment ions of lower charge whose m/z is greater than the precursor m/z, thus indicating a multiply charged precursor.
Note that, in addition, comet
includes
a precursor_charge
parameter. If the first number in
this parameter is set to 0, i.e., precursor_charge = 0 0
,
then the charge state rule above is applied. However, if a user
specifies a precursor charge range, i.e., precursor_charge = 1
5
, then Comet will search every spectrum through this range of
assumed charge states for every spectrum whose precursor charge
is unknown.
The options enzyme
(for tide-index
)
and search_enzyme_number
(for comet
) define
the enzymatic cleavage rules. When enzyme=no-enzyme
or search_enzyme_number=0
, then any subsequence of a
protein may be considered as a candidate peptide. For other values of
these parameters, the residues at the termini of the protein
subsequence must follow specific rules. For example, trypsin requires
that the preceeding residue must be an R or K and the following
residue may not be a P.
When digestion=full-digest
(for tide-index
)
or num_enzyme_termini=2
(for comet
), then
these rules must be true at both ends of the peptide. When it
is digestion=partial-digest
or num_enzyme_termini=1
, then the rules must be true at
at least one of the ends. The missed-cleavages
and allowed_missed_cleavages
parameters control the
maximum number of cleavage sites that may lie within the peptide
sequence.
Note that if enzyme=no-enzyme
or search_enzyme_number=0
, then
the digestion
, num_enzyme_termini
, missed-cleavages
and allowed_missed_cleaveages
parameters are not used.
The Crux search tools (tide-index
and comet
)
select candidate peptides for each spectrum based on its precursor
singly charged mass (m+h) or the mass-to-charge (m/z) and an assumed
charge state (specified in the input file). If the m+h and charge is
provided in the input file (e.g., from the Z lines of an MS2 file),
then the precursor mass is calculated from the m+h minus the mass of a
proton. Otherwise, the precursor mass is calculated from the precursor
m/z and an assumed charge. A mass window is defined in one of three
ways based on the
precursor-window-type
and precursor-window
options.
Candidate peptides are those whose mass falls within the defined window. The peptide mass is computed as the sum of the average amino acid masses plus 18 Da for the terminal OH group. Candidate peptides can also be constrained by minimum and maximum allowed length.
Although the syntax for specifying amino acid modifications differs between Comet and Tide, the logic of how those modifications are applied is similar.
First, it's important to understand that the search tools support several different types of modifications. A static modification is one that applies to every occurrence of an amino acid, whereas a variable modification means that the amino acid can occur in either form (modified or unmodified). Furthermore, unlike standard modifications that occur on amino acid side-chains, a terminal modification is applied to the molecular group at the N- or C-terminus of a peptide or protein. Typically, protein terminal modifications correspond to biological events, whereas peptide terminal modifications (which by definition must be applied after enzymatic digestion) are produced by the experimental workflow.
Conceptually, all static modifications (standard ones and terminal ones) are applied first. Thereafter, variable modifications are applied on top of static modifications. Tide applies at most one static modification and one variable modification at any location, terminal or non-terminal. Comet is similar, except that modifications can also separately be applied to terminal locations. For example, the peptide DEAGFK can have a variable modification on the side chain of the lysine residue as well as a variable modification on the peptide C-terminus.
In practice, it is an error to (try to) specify two different static modifications for the same type of residue, but perfectly legal to specify multiple variable modifications for the same residue.
In the search engine output, you will see the unmodified peptide (e.g., K[-16.9981]VLGHIR in Comet's "plain_peptide" column) and the peptide with variable modifications indicated in brackets (e.g., K[-16.9981]VLGHIR in Comet's "peptide" column and Tide's "sequence" column). The full set of modifications (including static modifications) is specified as a comma-separated list in the "modifications" column, like this: 1_S_45.0294,1_S_45.0239_n,1_V_-16.9981. This specification indicates that the first amino acid has a standard static modification of 45.0294 as well as a static n-terminal modification of 45.0239. In addition, the same residue has a variable modification of -16.9981.
Note that Comet allows slightly more flexibility than Tide in specifying different types of modifications. Terminal modifications in Comet can be specified to occur within a range of amino acids near the terminus. Also, via the "binary set" flag, a modification can be required to appear on all or none of the residues in a given peptide.
Peptide and protein terminal modifications are similar in their logic.
The (c/n)term-peptide-mods-spec
option applies modifications to the terminals
of all peptides, whereas (c/n)term-protein-mods-spec
applies modifications only
to peptide terminals that are also protein terminals. If both peptide and protein
mod specs are provided, then both will be applied. It is possible to simultaneously
specify peptide and protein terminal mods for the same type of residue. If both
are static then protein terminals will have both of them (sum of the mod masses).
If both are variable then they will be applied one at a time.
Note that the Tide index does not store information about the origin of variable mods. As a result, the Tide search output, unlike Comet, does not discriminate between terminal and non-terminal mods. Thus, Tides modified sequence column always has format K[-16.9981]VLGHIR, whereas in Comet the same peptide would be specified as n[-16.9981]VLGHIR for a terminal mod and K[-16.9981]VLGHIR for a non-terminal mod. Similarly, the modifications column in Tide search results always has the format [position]_V_[mass]. Static modifications do not have this issue: they will have a _c or _n suffix for peptide terminal mods and _C or _N for protein terminal mods.
Reducing the precursor mass tolerance has two main benefits. One is
reduced search time, and the other is improved statistical power to
detect matches. With a smaller window, fewer candidates are tested
against a spectrum. As a result, the statistical confidence measure
calculated after multiple testing correction will be more significant.
Of course, the flipside is that if you make the precursor window too
small, then you may end up throwing out correct identifications.
Control over the size of the window is provided by the using
the precursor-window
and
precursor-window-type
options.
Isotopically labeled data is accommodated by specifying various static or
variable modifications. The specific types of modifications differ according
to the labeling scheme, and the syntax for specifying the modifications
differs between Tide (which uses options like --mods-spec
) and
Comet (which uses options like add_Nterm_peptide
). In each of
the following entries, we provide first the Tide options, followed by the
Comet options.
iTRAQ 4-plex:
--mods-spec K+144.10253 --nterm-peptide-mods-spec X+144.10253
add_Nterm_peptide = 144.10253
add_K_lysine = 144.10253
clear_mz_range = 113.5 117.5
The 4-plex reagent has different monoisotopic mass values for 114 (144.105918), 115 (144.09599), and 116/117 (144.102063). The mass value used above is derived from averaging the three monoisotopic masses.
iTRAQ 8-plex:
--mods-spec K+304.2022 --nterm-peptide-mods-spec X+304.2022
add_Nterm_peptide = 304.2022
add_K_lysine = 304.2022
clear_mz_range = 112.5 121.5
The mass modification above is the average of the two different set of masses for 115/118/119/121 (304.199040) and 113/114/116/117 (304.205360).
TMT 2-plex:
--mods-spec K+225.155833 --nterm-peptide-mods-spec X+225.155833
add_Nterm_peptide = 225.155833
add_K_lysine = 225.155833
clear_mz_range = 125.5 127.5
TMT 6-plex:
--mods-spec K+229.162932 --nterm-peptide-mods-spec X+229.162932
add_Nterm_peptide = 229.162932
add_K_lysine = 229.162932
clear_mz_range = 127.5 131.5
SILAC 4Da:
There are a number of different SILAC reagents with a ~4 Da modification (based on combinations of C13 and N15), each with different sites of specificity. The example below is for the 15N(4) reagent applied to R residues. You should adjust the modification mass and residue(s) applied to as necessary.
To perform a mixed light/heavy search using a variable modification search:
--mods-spec 3R+3.988140
variable_mod01 = 3.988140 R 1 3 -1 0 0
Note that, in the example above, Comet operates in “binary” mode, which means that it only considers peptides in which all or none of the lysine residues are light/heavy. Tide does not support binary mode searching, so it will consider all peptides with up to 3 (in the above specification) heavy lysines.
To search just the heavy labeled sample, you can apply a static modification:
--mods-spec R+3.988140
add_K_lysine = 3.988140
SILAC 6Da:
This example uses the 13C(6) SILAC mass, assuming it is applied to both K and R. You should adjust as necessary. There is at least one more SILAC reagent with ~6 Da modification mass and different residue specificity: 13C(5) 15N(1)
To perform a mixed light/heavy search using a variable modification:
--mods-spec 3KR+6.020129
variable_mod01 = 6.020129 KR 1 3 -1 0 0
To search just the heavy labeled sample, you can apply a static modification:
--mods-spec KR+6.020129
add_K_lysine = 6.020129
add_R_arginine = 6.020129
SILAC 8Da:
The example below is for 13C(6) 15N(2) on K residues. Variable modification search:
--mods-spec 3K+8.014199
variable_mod01 = 8.014199 K 1 3 -1 0 0
Static modification for just the heavy labeled search:
--mods-spec K+8.014199
add_K_lysine = 8.014199
100% 15N label:
The N15 labeling adds 0.997035 mass difference for every nitrogen in each amino acid. So for a 100% N15 analysis, specify a static modification (between 1 and 4) to every amino acid residue, like this:
--mods-spec A+0.997035,C+0.997035,D+0.997035,E+0.997035,F+0.997035,G+0.997035,H+2.99111,I+0.997035,K+1.99407,L+0.997035,M+0.997035,N+1.99407,P+0.997035,Q+1.99407,R+3.98814,S+0.997035,T+0.997035,V+0.997035,W+1.99407,Y+0.997035
add_G_glycine = 0.997035 # added to G - avg. 57.0513, mono. 57.02146 add_A_alanine = 0.997035 # added to A - avg. 71.0779, mono. 71.03711 add_S_serine = 0.997035 # added to S - avg. 87.0773, mono. 87.03203 add_P_proline = 0.997035 # added to P - avg. 97.1152, mono. 97.05276 add_V_valine = 0.997035 # added to V - avg. 99.1311, mono. 99.06841 add_T_threonine = 0.997035 # added to T - avg. 101.1038, mono. 101.04768 add_C_cysteine = 0.997035 # added to C - avg. 103.1429, mono. 103.00918 add_L_leucine = 0.997035 # added to L - avg. 113.1576, mono. 113.08406 add_I_isoleucine = 0.997035 # added to I - avg. 113.1576, mono. 113.08406 add_N_asparagine = 1.99407 # added to N - avg. 114.1026, mono. 114.04293 add_D_aspartic_acid = 0.997035 # added to D - avg. 115.0874, mono. 115.02694 add_Q_glutamine = 1.99407 # added to Q - avg. 128.1292, mono. 128.05858 add_K_lysine = 1.99407 # added to K - avg. 128.1723, mono. 128.09496 add_E_glutamic_acid = 0.997035 # added to E - avg. 129.1140, mono. 129.04259 add_M_methionine = 0.997035 # added to M - avg. 131.1961, mono. 131.04048 add_O_ornithine = 1.99407 # added to O - avg. 132.1610, mono 132.08988 add_H_histidine = 2.99111 # added to H - avg. 137.1393, mono. 137.05891 add_F_phenylalanine = 0.997035 # added to F - avg. 147.1739, mono. 147.06841 add_U_selenocysteine = 0.997035 # added to U - avg. 150.3079, mono. 150.95363 add_R_arginine = 3.98814 # added to R - avg. 156.1857, mono. 156.10111 add_Y_tyrosine = 0.997035 # added to Y - avg. 163.0633, mono. 163.06333 add_W_tryptophan = 1.99407 # added to W - avg. 186.0793, mono. 186.07931 add_B_user_amino_acid = 0.0000 # added to B - avg. 0.0000, mono. 0.00000 add_J_user_amino_acid = 0.0000 # added to J - avg. 0.0000, mono. 0.00000 add_X_user_amino_acid = 0.0000 # added to X - avg. 0.0000, mono. 0.00000 add_Z_user_amino_acid = 0.0000 # added to Z - avg. 0.0000, mono. 0.00000
If you need to adjust the cysteine mass to account for carboxyamidomethylation, then use 58.018499 instead of 0.997035 for C.
--mods-spec A+0.997035,C+58.018499,D+0.997035,E+0.997035,F+0.997035,G+0.997035,H+2.99111,I+0.997035,K+1.99407,L+0.997035,M+0.997035,N+1.99407,P+0.997035,Q+1.99407,R+3.98814,S+0.997035,T+0.997035,V+0.997035,W+1.99407,Y+0.997035
add_C_cysteine = 0.997035
Patches implementing new features can submitted directly as pull requests on github, or can be be emailed to the development team at<EMAIL_ADDRESS>for review and inclusion in subsequent releases of Crux.
Thin air. The name is not an acronym or a reference to anything in particular.


+++ title = "Pedagaggi" lat = 37.193552 lon = 14.938488 +++
Pedagaggi is a teeny village — in the northern foothills of Sicily's Monti Iblei — which overlooks the plain of Catania, and Mount Etna beyond. I camped it rough in a spot about ½ an hour north of Pedagaggi this evening, and I rode through the village the following morning.


To load a web based graph or layers model saved for tensorflowjs
Trying to load this model that I converted from an Edge Impulse Tensorflow Saved model to load for TensorflowJS
https://hpssjellis.github.io/my-examples-of-edge-impulse/public/edge-models/single-heart-rock/forweb/model.json
LOAD any TFJS Layers URL
Shows summary on this site but also in the console
Open console using, ctrl shift i
right-click view source to see this one page Vanilla Javascript code
try for a TensorflowJS layers model try:
https://www.rocksetta.com/tensorflowjs/saved-models/batches-20000-done.json
https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json
https://hpssjellis.github.io/beginner-tensorflowjs-examples-in-javascript/saved-models/mnist/convnet/my-mnist01.json
https://storage.googleapis.com/tfjs-models/tfjs/squeezenet_v1.1/model.json
...
LOAD Vision Graph Model From TF Hub
Shows the results after loading zeros data since Graph models can't show a summary
For a TensorflowJS graph model from TF-Hub try
https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2
Presently tested with const zeros = tf.zeros([1, , , ]);
check console
LOAD Vision Graph Model From anywhere
Shows the results after loading zeros data since Graph models can't show a summary
For a TensorflowJS graph model try
https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json
Presently tested with const zeros = tf.zeros([1, , , ]);


Library: Net
Package: NetCore
Header: Poco/Net/DNS.h
Description
This class provides an interface to the domain name service.
An internal DNS cache is used to speed up name lookups.
Member Summary
Member Functions: aierror, error, flushCache, hostByAddress, hostByName, hostName, lastError, reload, resolve, resolveOne, thisHost
Enumerations
HintFlag
DNS_HINT_NONE = 0
DNS_HINT_AI_PASSIVE = 0x00000001
Socket address will be used in bind() call
DNS_HINT_AI_CANONNAME = 0x00000002
Return canonical name in first ai_canonname
DNS_HINT_AI_NUMERICHOST = 0x00000004
Nodename must be a numeric address string
DNS_HINT_AI_NUMERICSERV = 0x00001000
Servicename must be a numeric port number
DNS_HINT_AI_ALL = 0x00000100
Query both IP6 and IP4 with AI_V4MAPPED
DNS_HINT_AI_ADDRCONFIG = 0x00000400
Resolution only if global address configured
DNS_HINT_AI_V4MAPPED = 0x00000800
On v6 failure, query v4 and convert to V4MAPPED format
Member Functions
flushCache
static void flushCache();
Deprecated. This function is deprecated and should no longer be used.
Flushes the internal DNS cache.
As of 1.4.2, the DNS cache is no longer used and this method does not do anything.
hostByAddress
static HostEntry hostByAddress(
const IPAddress & address,
unsigned hintFlags = DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
);
Returns a HostEntry object containing the DNS information for the host with the given IP address. HintFlag argument is only used on platforms that have getaddrinfo().
Throws a HostNotFoundException if a host with the given name cannot be found.
Throws a DNSException in case of a general DNS error.
Throws an IOException in case of any other error.
hostByName
static HostEntry hostByName(
const std::string & hostname,
unsigned hintFlags = DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
);
Returns a HostEntry object containing the DNS information for the host with the given name. HintFlag argument is only used on platforms that have getaddrinfo().
Throws a HostNotFoundException if a host with the given name cannot be found.
Throws a NoAddressFoundException if no address can be found for the hostname.
Throws a DNSException in case of a general DNS error.
Throws an IOException in case of any other error.
hostName
static std::string hostName();
Returns the host name of this host.
reload
static void reload();
Reloads the resolver configuration.
This method will call res_init() if the Net library has been compiled with -DPOCO_HAVE_LIBRESOLV. Otherwise it will do nothing.
resolve
static HostEntry resolve(
const std::string & address
);
Returns a HostEntry object containing the DNS information for the host with the given IP address or host name.
Throws a HostNotFoundException if a host with the given name cannot be found.
Throws a NoAddressFoundException if no address can be found for the hostname.
Throws a DNSException in case of a general DNS error.
Throws an IOException in case of any other error.
resolveOne
static IPAddress resolveOne(
const std::string & address
);
Convenience method that calls resolve(address) and returns the first address from the HostInfo.
thisHost
static HostEntry thisHost();
Returns a HostEntry object containing the DNS information for this host.
Throws a HostNotFoundException if DNS information for this host cannot be found.
Throws a NoAddressFoundException if no address can be found for this host.
Throws a DNSException in case of a general DNS error.
Throws an IOException in case of any other error.
aierror
static void aierror(
int code,
const std::string & arg
);
Throws an exception according to the getaddrinfo() error code.
error
static void error(
int code,
const std::string & arg
);
Throws an exception according to the error code.
lastError
static int lastError();
Returns the code of the last error.


Thoughts on life, work and anything in between.
Launching my website (It's all fun!) 15th August 2019


Currently, I am enrolled at We Can Code It, as a Junior Developer. Prior to this I have worked in
retail banking for the past 15 years. Starting as a Teller, and ending most recently as a Financial
Services Representitive. I found intrest in coding after talking to some of the developers working on
a platform change at my previous employer, and talking with a co-worker who went through the WCCI bootcamp.


IRS Playing Fair With Transparent Crypto Tax Filings
by Christine VasilevaContrary to its portrayed draconian stance on crypto taxes, the US Internal Revenue Service is playing fair. Exercising transparency in reporting numbers is the key, and may save crypto traders thousands in tax bills.
IRS Appreciates Detailed Crypto Transaction and Trading History
A detailed history of crypto transactions and sales may significantly reduce the outstanding tax bill and clear users from unwanted scrutiny reported Bloomberg.
As a routine, the IRS sends out letters to warn taxpayers to present undisclosed earnings. However, US traders need not worry. A detailed history of crypto transactions, as well as trades and logged gains or losses, could make all the difference. The IRS recently put out a rather complex set of rules for digital assets, which confused quite some crypto owners. But it turns out that, in most cases, a taxable event occurs once the coins are sold.
In the summer, the IRS worried crypto social media, by sending out 10,000 Letter 6173s. But with some support, owners of digital assets were able to save thousands of dollars in taxes.
Assistance with Building Tax Report Offered by CoinTracker
CoinTracker, a startup specializing in blockchain history and transactions, has helped with the matter.
“I personally worked with a user where the IRS was saying that they owed thousands of dollars on a CP2000 notice,” said Chandan Lodha, co-founder of CoinTracker. “And then after they presented their full transaction history, the user actually ended up with a refund.”
Lodha, however, commented that the IRS did not glean its information from blockchains. Instead, it relied on third-party reporting through Form 1099-K. This meant that crypto assets were liquidated and somewhere, a fiat transaction was logged and reported. So far, no letters have been received from the IRS based on hard fork activity, except crypto transactional activities concerning exchange or brokerage sales.
Traders with a long and convoluted history of crypto trading could offer a summary form, suggested Lodha.
“It can’t hurt to provide as much detail as possible, but for taxpayers with extremely voluminous histories of crypto trades, the IRS can be reasonable in my experience in accepting summary information plus corroboration, he said in an email,” Lodha said.
CoinTracker also discovered that the IRS is not extremely harsh if a person makes the best attempt to report on their crypto-related activity. However, failing to report revenues recognized by third parties is treated as a transgression.
BTC is on track to log a significant paper gain in 2019, rising more than 100% net even with corrections. However, a taxable event may be quite different for someone who sold at peak prices versus more depressed positions.
What do you think about the IRS stance on crypto gains and taxation? Share your thoughts in the comments section below!
Image via Shutterstock
The Rundown


The goal of the hackathon is to (i) find a team with which you can (ii) define a research demo application which you can publish at a scientific conference, and then (iii) implement it in two days time. It’s actually big fun and it gives you the opportunity to learn to knew new people, learn new things ... and publish a new paper.
| Who is invited? | PhD students, post docs, researchers, teachers, professors, etc. | |
| Where and When? | 21. to 22. of December, 2016 / AAU Klagenfurt | |
| Why should we do that? | Because it’s fun, and you can meet your co-workers, and it is a great way to add a finishing line to the year 2016, and you can make contacts, and you can publish the results, and and and ... |
| 10:00 | Welcome and Introduction | Dec. 21 / Z.1.09 | |
| 10:15 | Brainstorming | Dec. 21 / Z.1.09 | |
| 10:45 | Project Pitch | Dec. 21 / Z.1.09 | |
| 11:30 | Hacking | Dec. 21 / Z.1.09 | |
| 17:00 | Day 01 - Resumee | Dec. 21 / Z.1.09 | |
| 10:00 | Breakfast, then Hacking | Dec. 22 / E.2.42 | |
| 16:00 | Presentation | Dec. 22 / E.2.42 | |
| Add Hackathon to calender |
Sorry, it's only German for the time being. Send me a pull request for a translation :)


#include <BscParseLib.h>
Public Member Functions | |
| SBscItemValue () | |
| lib header. | |
| ~SBscItemValue () | |
Public Attributes | |
| EBSCITEMTYPE | type |
| used internally to know what data to delete. | |
| unsigned int | itemId |
| item ID... set when a value is parsed in. | |
| unsigned int | flagValues |
| data that depends on what kind of parameter we're dealing with. | |
| URef< UExprTerm > * | exprs |
| unsigned int | exprCount |
| UPath * | paths |
| unsigned int | pathCount |
| tstring * | strings |
| unsigned int | stringCount |
| tstring * | idents |
| unsigned int | identCount |
Definition at line 83 of file BscParseLib.h.
| SBscItemValue::SBscItemValue | ( | ) |
lib header.
File: BscParseLib.cpp Author: Kevin Bray Created: 07-07-05 Copyright © 2004 Bootstrap Studios. All rights reserved. project includes. SBscItemValue dtor.
Definition at line 26 of file BscParseLib.cpp.
| SBscItemValue::~SBscItemValue | ( | ) |
Definition at line 43 of file BscParseLib.cpp.
| unsigned int SBscItemValue::exprCount |
Definition at line 98 of file BscParseLib.h.
Definition at line 97 of file BscParseLib.h.
| unsigned int SBscItemValue::flagValues |
data that depends on what kind of parameter we're dealing with.
Definition at line 95 of file BscParseLib.h.
| unsigned int SBscItemValue::identCount |
Definition at line 107 of file BscParseLib.h.
Definition at line 106 of file BscParseLib.h.
| unsigned int SBscItemValue::itemId |
| unsigned int SBscItemValue::pathCount |
Definition at line 101 of file BscParseLib.h.
Definition at line 100 of file BscParseLib.h.
| unsigned int SBscItemValue::stringCount |
Definition at line 104 of file BscParseLib.h.
Definition at line 103 of file BscParseLib.h.


description = "Solutions-Contact Us" [viewBag] == {% put styles %} {% endput %} {% for record in office_list %} {% endfor %} {% for record in office_list %} {{record.office_name}} {{record.office_address}} Tel: {{record.office_tel}} Email: {{record.contact_email}} {% endfor %} {{'Contact Us'|_}} {{'Headquartered in Hong Kong, we have offices in China, Canada and The Netherlands. We are active in more than 20 countries around the world.'|_}}
{{record.office_name}}
{{record.office_address}}
Tel: {{record.office_tel}} Email: {{record.contact_email}}
{{'Contact Us'|_}}


I think you are not having an account...
create an account by signing up here or check the details correctly
SignUp
Check Again


{% extends "base.html" %} {% load i18n %} {% load static %} {% load cache %} {% load twlight_perms %} {% load twlight_wikicode2html %} {% get_current_language as LANGUAGE_CODE %} {% block extra_css %} {% endblock extra_css %} {% block content %}
{% comment %} Cache lifetime should be None, which would be forever since we're invalidating on update. However, as 2017-04-06 a bug in django doesn't allow for None to be passed from here into cache. The fix is in master, but not release. https://code.djangoproject.com/ticket/27882 We filter out details and summary tags so that we always see the full content on the details page. {% endcomment %} {% filter removetags:"details summary" %} {% cache 31536000 partner_description LANGUAGE_CODE object.pk %} {{ object.description | twlight_wikicode2html | safe }} {% endcache %} {% endfilter %}
{% else %} {% trans "Description not available." %} {% endif %} {% for tag in object.tags.all %} {{ tag }} {% endfor %}{% with object.get_languages as language_list %} {% blocktrans trimmed %} Language(s): {{ language_list }} {% endblocktrans %} {% endwith %}
{% else %}{% trans "Languages not available." %}
{% endif %}{% trans "Terms of use not available." %}
{% endif %}{% blocktrans count counter=total_apps_approved %} Number of applications approved (all time): {{ total_apps_approved_or_sent }} {% plural %} Number of applications approved (all time): {{ total_apps_approved_or_sent }} {% endblocktrans %}
{% blocktrans count counter=unique_users_approved %} Number of unique users with approved applications (all time): {{ unique_users_approved_or_sent }} {% plural %} Number of unique users with approved applications (all time): {{ unique_users_approved_or_sent }} {% endblocktrans %}


| What is Lorem Ipsum? | Why do we use it? | Where does it come from? |
|---|---|---|
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum. Lorem IpsumLorem Ipsum Lorem Ipsum |
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like). |
Contrary to popular belief, Lorem Ipsum is not simply random text.  Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32. The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from "de Finibus Bonorum et Malorum" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham. |


Have you tried using any of the insight and techniques for growing trust and sincerity? How did it go?
I like to think of myself as someone who reads people well and with ease. I can tell straight away if someone is genuine or sincere by their body language, the way they hold themselves and the tone of their voice. I am constantly testing new people to see whether I can gain trust, and I can tell pretty fast if I can or not. I immediately take a step back from the person if I can no longer trust them, or if I can trust them I let in pretty quick as I am very open person, and I don’t let people in easily. I feel like as NZers we are extremely trustworthy people in general compared to other countries. A good example of this would be TradeMe. Its amazing the level of trust that some people place on the buyers or the sellers really, Trademe must have really good scam filters, or NZers must just be really open and trustworthy people. For example: Pick ups. There is not many places in the world where I can think of that you often have someones email adders, phone number, bank acc details, and then physical address if you want to pick up! That to me is crazy!
Try empathic listening - how did it go?
Empathy:
Empathy is a skill that for all the social competencies -Understanding others -Developing others -Political awareness.I would say this is always how I listen to people. I think its pretty rude if someone is not caring about what the person talking to them is saying.. I did the exercise with my partner and I talked about how I was feeling about EDA and bootcamp about to start. I felt like it was rather distressing talking to her about it as she is a developer and wants me to do well, and my fear is that I am not feeling confident with the material therefore anxious about the course. When it was my turn to listen to her she told about her problems with one of her business partners being an alpha male and never listening to her and in this case, ignoring her suggestions, then claiming them as his later on. The meta conversation just involved us comforting each other basically.
How did you find the loving kindness meditation?
I found myself smiling, so its effective!!
Complete the political awareness exercise here in writing.
I did this out loud to myself, I found it pretty strange to be honest, to be saying a monologue I already knew of. But it was interesting to see the points from the other side, I did find it hard to be completely convinced of their side of things.. haha
Any other musings?
This book is starting to really feel like it is recycling a lot of old concepts but giving them a new name… repeating itself a lot, or maybe the concepts/exercises are just similar..hmmm..


| Step | Instruction |
|---|---|
| 1. | Create a tenant organization |
| 2. | Generate the RSA private and public key pair |
| 3. | Get the public key registered in production |
| 4. | Create organizations, and users, and register |
| 5. | Single Sign-On with Sunbird |
Tokens are used to authenticate users across Sunbird instances, networks or applications via SSO (Single Sign-on). The JWT provided to the auto-login endpoint must contain the following fields (also known as claims) in its payload.
jti: a unique ID of the token. This can be any unique string generated by the sender
iss: the issuer of the JWT. This must be the ID of the registered client
sub: the subject of the token. This must be the user ID of the person who is signed in
aud: the consumer of the token. This is the site or instance address. For example; in case of the DIKSHA platform, currently it is https://www.ntp.in
nbf: not before. This indicates the earliest time when the token can be used. It is expressed as the number of seconds since epoch in GMT. The nbf time cannot be in the future
exp: expires. The timestamp when the token expires. It is expressed as the number of seconds since epoch in GMT. The expiry time cannot be more than 600 seconds after the nbf time.
name: The name of the person whose user ID is in the subject
email: The email ID of the person whose user ID is in the subject
email_verified: An indicator whether the email ID has been verified. This is important when only verified user email IDs are accepted on an instance. For example; only verified emails are accepted on DIKSHA
phone_number: The 10 digit phone number of the person whose user ID is in the subject. This is an optional field
phone_number_verified: An indicator whether the phone number has been verified. This is important when only verified user phone numbers are accepted on an instance. For example; only verified phone numbers are accepted on DIKSHA. This field is optional
redirect_url: the url of the page where the user should be directed after login
Sample Payload for Single Sign-On
{ "jti": "261263cd-3a0e-4aee-8faf-6d9d9eb14bb1", "iss": "replace with id provided by at registration time", "sub": "someuserid", "aud": "base_url", "iat":<PHONE_NUMBER>, "exp":<PHONE_NUMBER>, "name": "Some User", "email"<EMAIL_ADDRESS>"email_verified": true, "phone_number": "+91.9555-999-555", "phone_number_verified": true, "redirect_uri": "base_url/private/index#!/workspace/content/create" }
Provide the base URL for for the instances created. For example;
Sign the payload described before sending it to the authentication endpoint. The JWT specification permits signing via HMAC, RSA or ECDSA algorithms. For this authentication end-point, the only permitted algorithm is RSA signing via a private key. The corresponding public key is provided during registration of the client.
For details on creating a RSA-signed JWT in Java, refer to JWT with RSA Signature
Sunbird allows creation and configuration of multiple tenant organizations within a single instance:
Every tenant organization has a unique channel; i.e. all the activities by users belonging to that tenant organization are tagged with the tenant’s channel ID. For example, on DIKSHA, activities include content creation, content consumption, etc.
Tenant organizations have the option to setup a custom home page and configure the logo to be displayed for users who belong to the tenant
Tenant organizations can create multiple sub-organizations and add users to those organizations. For example, on DIKSHA, each state is a tenant on Sunbird and all schools or institutes in that state are created as sub-organizations under that tenant organization.
To create a new pair of public/private keys, run the following command:
{ $ openssl genrsa -out private.pem 2048 }
This private key must be kept secret. To generate a public key corresponding to the private key, execute:
{ $ openssl rsa -in private.pem -outform PEM -pubout -out public.pem }
On running these commands, the public key is written in public.pem, while the private key is written in private.pem
To access APIs using the token, the generated token should be sent in the Authorization header of the request with the value: bearer
curl -H "Authorization: Bearer <token>" https://staging.ntp.net.in/api/echo/hello
Sunbird allows you to override the default home page and configure a custom home page and logo for each tenant who is onboarded. The tenant organization should provide a package containing the following files to customise the home page and logo:
The home page html file - named as index.html. All the dependent files, like js, css and images, used by the home page should be within the package and referred using relative paths from the “index.html”.
Logo of the tenant - named as logo.png
Tenants also have an option to configure the following:
an icon - to be displayed as browser favicon, named as favicon.ico
a poster image - to be used as a flash screen in the mobile app, named as poster.png
Place all the files in a single folder, with the same name as the channel value of the tenant organization
Add the following link at an appropriate place in the custom home page to invoke Sunbird portal login:
href="/private/index" title="Sign In">Sign In


Introduction
Coronavirus disease (COVID-19) is an infectious disease caused by a newly discovered coronavirus (WHO, 2020). Now, 32,784,889 confirmed cases of COVID-19 have been reported in 213 countries and regions around the world (WORLDOMETER, 2020).Toronto health officials announced the first case of COVID-19 in Canada on January 25, after that, the COVID-19 cases increases rapidly in Canada (Thomas, 2020). There are about 17,259 cases in Toronto up until September 26th, 2020 and the number is increasing everyday (City of Toronto, 2020). As the result, we need to take this case seriously. For people who live in Toronto, they need to know how should they deal with this situation and stay safe. One way in my opinion is to find out the most possible source of infection in Toronto because the result can be a reference for citizens to know what are the latent threats to their health and to avoid further infections for themselves.
I chose About COVID-19 Cases in Toronto dataset from Toronto Open Data to find out which infection has the strongest relationship with the COVID-19 cases in Toronto. I drew a Bar Plot which include a list of source of infections related to the cases. Each category shows how many cases are related to one specific infection, which is clear to be concluded. Base on the bar plot, I found that Close contact has the highest count for about 6500 cases. Which means most of the observants was in close contact with a confirmed or probable COVID-19 case, for example they were reside in the same household with a confirmed or probable COVID-19 case.
From this graph, we can find out that it is important to remember the most efficient way to protect ourselves from COVID-19 is to stay at home and avoid gather around. With this graph as a reference, people in Toronto can be more aware of what they should avoid and what they should remember for the further protection as well as stay away from some rumor. One limitation for this dataset is the numbers that Toronto Open Data have may be different from those published elsewhere because the data was extracted at different times and come from different sources, which means it would be hard to decide which number may be the most precise one.
About the Dataset
In the context of the evolving global epidemic, Toronto’s public health department is responding to the ongoing COVID-19 outbreak. This data set contains demographic, geographic information and severity information of all confirmed and probable cases that have been reported to and managed by Toronto Public Health since the first case was reported in January 2020. These include sporadic (occurring in the community) and fulminant cases-related. Data is extracted from the Provincial Infectious Disease Reporting System (iPHIS) and Toronto’s customized COVID-19 Case Management System (CORES), and combined for reporting. Each row summarizes the information of a case.
A Brief Graph About the Dataset
## # A tibble: 6 x 18
## `_id` Assigned_ID `Outbreak Assoc… `Age Group` `Neighbourhood … FSA
## <int> <int> <chr> <chr> <chr> <chr>
## 1 143647 1 Sporadic 50 to 59 Y… Willowdale East M2N
## 2 143648 2 Sporadic 50 to 59 Y… Willowdale East M2N
## 3 143649 3 Sporadic 20 to 29 Y… Parkwoods-Donal… M3A
## 4 143650 4 Sporadic 60 to 69 Y… Church-Yonge Co… M4W
## 5 143651 5 Sporadic 60 to 69 Y… Church-Yonge Co… M4W
## 6 143652 6 Sporadic 50 to 59 Y… Newtonbrook West M2R
## # … with 12 more variables: `Source of Infection` <chr>, Classification <chr>,
## # `Episode Date` <chr>, `Reported Date` <chr>, `Client Gender` <chr>,
## # Outcome <chr>, `Currently Hospitalized` <chr>, `Currently in ICU` <chr>,
## # `Currently Intubated` <chr>, `Ever Hospitalized` <chr>, `Ever in
## # ICU` <chr>, `Ever Intubated` <chr>
Data summary
| Name | data |
| Number of rows | 17872 |
| Number of columns | 18 |
| _______________________ | |
| Column type frequency: | |
| character | 16 |
| numeric | 2 |
| ________________________ | |
| Group variables | None |
Variable type: character
| skim_variable | n_missing | complete_rate | min | max | empty | n_unique | whitespace |
|---|---|---|---|---|---|---|---|
| Outbreak Associated | 0 | 1 | 8 | 19 | 0 | 2 | 0 |
| Age Group | 0 | 1 | 3 | 14 | 0 | 10 | 0 |
| Neighbourhood Name | 0 | 1 | 3 | 35 | 0 | 141 | 0 |
| FSA | 0 | 1 | 3 | 3 | 0 | 97 | 0 |
| Source of Infection | 0 | 1 | 6 | 25 | 0 | 8 | 0 |
| Classification | 0 | 1 | 8 | 9 | 0 | 2 | 0 |
| Episode Date | 0 | 1 | 10 | 10 | 0 | 217 | 0 |
| Reported Date | 0 | 1 | 10 | 10 | 0 | 212 | 0 |
| Client Gender | 0 | 1 | 4 | 11 | 0 | 5 | 0 |
| Outcome | 0 | 1 | 5 | 8 | 0 | 3 | 0 |
| Currently Hospitalized | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
| Currently in ICU | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
| Currently Intubated | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
| Ever Hospitalized | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
| Ever in ICU | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
| Ever Intubated | 0 | 1 | 2 | 3 | 0 | 2 | 0 |
Variable type: numeric
| skim_variable | n_missing | complete_rate | mean | sd | p0 | p25 | p50 | p75 | p100 | hist |
|---|---|---|---|---|---|---|---|---|---|---|
| _id | 0 | 1 | 152582.50 | 5159.35 | 143647 | 148114.75 | 152582.5 | 157050.25 | 161518 | ▇▇▇▇▇ |
| Assigned_ID | 0 | 1 | 9026.35 | 5248.05 | 1 | 4482.75 | 8984.5 | 13529.25 | 18202 | ▇▇▇▇▇ |
Graph of Source of Infection About COVID-19 Cases in Toronto
In this paper, I’m going to look at different Source of Infection in COVID-19 Cases in Toronto. By looking up those infections as a reference, we can have a clear idea about what should we avoid and what should we remember for the further protection as well as avoid those rumors that threat people with no reason.
Discussion
The bar plot I drew shows the different sources of infection about 17872 COVID-19 cases in Toronto and how many cases does each source contain.
From the graph we can see Close contact has the highest count for about 6500 cases. Which means most of the observants was in close contact with a confirmed or probable COVID-19 case, for example they were reside in the same household with a confirmed or probable COVID-19 case. In this case, it is a warning for us to remember the most efficient way to protect ourselves and others is to stay at home and avoid gather around.
Something surprised is that N/A is also a high-count-category compare to other source of infection, which contains about 6000 cases in Toronto. It may be reasonable because all the cases included in N/A section are related to outbreak period, in that period, it may be hard to determine which source exactly cause the infection.
Moreover, it is worth noticing that there are also few cases, which are categorized as Unknown/Missing or Pending, which means source of infection does not identified or missing or information on source of infection is pending. In this severe period, it is a good habit to protect others that when people go out they remember where they go and who they contact with. This habit may make life easier for the government and public health institution to target the possible infected area and control a further coming outbreak as soon as possible.
As the public health investigation of the reported cases and the continuous quality improvement plan progress, the data in Toronto Open Data may change, and other cases will continue to be reported. It means none of the sources of infection is less threatening than others, no matter how many cases does one kind of infection has, people should be aware of all of them and try their best to avoid the infections.
Weaknesses
The numbers that Toronto Open Data have may be different from those published elsewhere because the data was extracted at different times and come from different sources, which means it would be hard to decide which number may be the most precise one.
Another limitation would be the correctness of classification. Since the source of infection may be overlapped, people may feel difficult to figure out what source exactly cause their infection to COVID-19. For example, people who are in Healthcare setting such as, family physician, dentist, ophthalmologist, sports doctor, may also be categorized in Institutional setting because they may as well work in long-term care homes, acute care hospitals, complex case hospitals, special-care facilities, retirement homes, rehabilitation hospitals.
References
-R Core Team (2020). R: A language and environment for statistical computing. R Foundation for Statistical Computing, Vienna, Austria. URL https://www.R-project.org/.
-JJ Allaire and Yihui Xie and Jonathan McPherson and Javier Luraschi and Kevin Ushey and Aron Atkins and Hadley Wickham and Joe Cheng and Winston Chang and Richard Iannone (2020). rmarkdown: Dynamic Documents for R. R package version 2.3. URL https://rmarkdown.rstudio.com.
- Wickham et al., (2019). Welcome to the tidyverse. Journal of Open Source Software, 4(43), 1686, https://doi.org/10.21105/joss.01686
-H. Wickham. ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York, 2016.
-Hadley Wickham, Romain Fran?ois, Lionel Henry and Kirill Müller (2020). dplyr: A Grammar of Data Manipulation. R package version 1.0.2. https://CRAN.R-project.org/package=dplyr
-Elin Waring, Michael Quinn, Amelia McNamara, Eduardo Arino de la Rubia, Hao Zhu and Shannon Ellis (2020). skimr: Compact and Flexible Summaries of Data. R package version 2.1.2. https://CRAN.R-project.org/package=skimr
-Sharla Gelfand (2020). opendatatoronto: Access the City of Toronto Open Data Portal. R package version 0.1.3. https://CRAN.R-project.org/package=opendatatoronto
-Toronto Public Health (Sept 23, 2020). https://open.toronto.ca/dataset/covid-19-cases-in-toronto/
-Coronavirus disease (COVID-19). (n.d.). Retrieved September 26, 2020, from https://www.who.int/emergencies/diseases/novel-coronavirus-2019
-Countries where COVID-19 has spread. (n.d.). Retrieved September 26, 2020, from https://www.worldometers.info/coronavirus/countries-where-coronavirus-has-spread/
-Thomas, D., & Nair, A. (2020, January 25). Canada identifies first case of coronavirus. Retrieved September 26, 2020, from https://www.reuters.com/article/us-china-health-canada-idUSKBN1ZO0T9
-City of Toronto. (2020, September 25). COVID-19. Retrieved September 26, 2020, from https://www.toronto.ca/home/covid-19/


migraine galcanezumab patients (.%) placebo (%) treatment Galcanezumab CGRP MHD <. clinical study trial (S) EVOLVE- efficacy Phase migraine: significant response headache {border-style (n= Headache episodic gene-related Neurol peptide preventive px;} #ffffff;} acute baseline chronic monthly results days randomized Dodick III calcitonin compared data Cephalalgia capsaicin-induced double-blind, phase prevention (NCT) (n=) P-value doses mean safety Injection-site EVOLVE-, Table blood month pain placebo-controlled primary randomized, receptor statistically therapy trials use Migraine Pharmacol collab: dose reduction Goadsby Lancet Placebo REGAIN administered adults antibody migraine. months patients, prophylaxis reported studies treatment-emergent trials, (.) (eg, -month DBF EM, Study adherence administration adverse associated binding change double-blind medication number prophylactic px; secondary similar study, subcutaneous time years {font-family Accessed Available Med Neurology TEAEs affected antibodies available controlled differences drugs effect font-size frequency from: improvement low monoclonal open-label randomised, release therapies treatment. (NCT), (ie, Aurora Bigal CM. Calcitonin Clin Company Eli Lilly Lipton Rev Safety Text adult analysis assessed barrier consecutive development did double; drug endpoint flow galcanezumab, galcanezumab-treated group injection-site mg) mg, model multiplicity period. placebo-controlled, placebo. post review significantly single therapeutic tract treated trigeminal August Brain CGRP, CGRP. ClinicalTrials.gov Curr Edvinsson MAbs, Negro P<. Pain Silberstein View Zhang anti-CGRP attacks border-color border-width cardiovascular cluster conducted days) demonstrated different disability early effects estimated evidence following functional greater groups hoc https://clinicaltrials.gov/ct/show/NCT inhibition key meaningful mechanism peripheral placebo, prefilled responses solid; tolerability {font-style {font-weight (.% (NS) AEs Abbreviations: Accordingly, Chronic Efficacy Importantly, MAb MAbs MHD, Monthly Multinational Participants Patients Risk Skljarevski Stauffer Ther achieved action adjustment. and, autoinjector bold clinically considered considering courier; current daily dermal does em; endpoints evaluation events galcanezumab. headache: healthy increase involvement levels long-term, max mg; migraine, months, observed patients. place preventing previous profile provided pt;} rate reduced reductions relevant respiratory sensory showed sodium specific statistical studied studies, suicidal syringe target targeting terms that, treatments


{% extends "layout.html" %} {% block body %} Edit a Post Change Fields to Edit a Post! Title A title is required! Sub-title A slug is required! Slug A slug is required! {{ post.content }} Content Content is required! 5 MB limit. {% if post_s_no != '0' %}If you do not upload an image, thumb image will stay unchanged.{% endif %} Send {% endblock %}
Change Fields to Edit a Post!


Food History
Archive
Resources
About
Food History
Categories
Recipes
Description
Spices
Description
Produce
Description
Events
Description


vignettes/BuildingDeepLearningModels.Rmd
BuildingDeepLearningModels.Rmd
Electronic Health Records (EHR) data is high dimensional, heterogeneous, and sparse, which makes predictive modelling a challenge. In the early days, the machine learning community mainly focused on algorithm development, currently there is a shift to more powerful feature engineering. Deep Learning models are widely used to automatically learn high-level feature representations from the data, and have achieved remarkable results in image processing, speech recognition and computational biology. Recently, interesting results have been shown using EHRs, but more extensive research is needed to assess the power of Deep Learning in this domain.
This vignette describes how you can use the Observational Health Data Sciences and Informatics (OHDSI) PatientLevelPrediction
package to build Deep Learning models. This vignette assumes you have read and are comfortable with building patient level prediction models as described in the BuildingPredictiveModels
vignette. Furthermore, this vignette assumes you are familiar with Deep Learning methods.
 These algorithms need a lot of data to converge to a good representation, but currently the sizes of the EHR databases are growing fast which would make Deep Learning an interesting approach to test within OHDSI’s Patient-Level Prediction Framework. The current implementation allows us to perform research at scale on the value and limitations of Deep Learning using EHR data. For relatively small Target and Outcome cohorts, Deep Learning is most probably not the best choice.
Most current Deep Learning research is performed in python and we have developed a pipeline to interact with python. Multiple Deep Learning backends have been developed, e.g. Tensorflow, PyTorch, Keras (recently also available in R) etc. In the package we have implemented interaction with Keras in R and PyTorch in Python but we invite the community to add other backends.
Many network architectures have recently been proposed and we have implemented a number of them, however, this list will grow in the near future. It is important to understand that some of these architectures require a 2D data matrix, i.e. |patient|x|feature|, and others use a 3D data matrix |patient|x|feature|x|time|. The FeatureExtraction Package has been extended to enable the extraction of both data formats as will be described with examples below.
Note that training Deep Learning models is computationally intensive, our implementation therefore supports both GPU and CPU. It will automatically check whether there is GPU or not in your computer. A GPU is highly recommended for Deep Learning!
We implemented the following non-temporal (2D data matrix) architectures using PyTorch:
1) Logistics regression (LRTorch)
A simple softmax layer with l2 regularization
2) Feed forward network (MLPTorch)
Supports multilayer perceptron (mlp_type = MLP) and
Self-Normalizing Neural Networks (mlp_type = SNN)
Reference: https://arxiv.org/abs/1706.02515
For the above two methods, we implemented support for a stacked autoencoder and a variational autoencoder to reduce the feature dimension as a first step. These autoencoders learn efficient data encodings in an unsupervised manner by stacking multiple layers in a neural network. Compared to the standard implementations of LR and MLP these implementations can use the GPU power to speed up the gradient descent approach in the back propagation to optimize the weights of the classifier.
Table 1: Non-Temporal Deep Learning Models Hyper-Parameters
| Name | Description | Hyper-parameters |
|---|---|---|
| LRTorch | Logistic Regression Model | w_decay (l2 regularization), epochs (number of epochs), class_weight (0 = inverse ratio between number of positive and negative examples, -1 = focal loss (https://arxiv.org/abs/1708.02002), or other), autoencoder (apply stacked autoencoder?, vae (apply variational autoencoder) |
| MLPTorch | Multi-Layer Perceptron Model | mlp_type (MLP = default, SNN = self-normalizing neural network), size (number of hidden nodes), w_decay (l2 regularization), epochs (number of epochs), class_weight(0 = inverse ratio between number of positive and negative examples, -1 = focal loss, or other), autoencoder (apply stacked autoencoder), vae (apply variational autoencoder?) |
The approach for logistic regression (LRTorch) and the Multi-Layer Perceptron (MLPTorch) is identical. Here we will take LRTorch as an example.
You need to generate a population
and plpData
object as described in more detail in BuildingPredictiveModels
vignette.
Alternatively, you can make use of the data simulator. The following code snippet creates a population of 12000 patients.
set.seed(1234)
data(plpDataSimulationProfile)
sampleSize <- 12000
plpData <- simulatePlpData(
plpDataSimulationProfile,
n = sampleSize
)
population <- createStudyPopulation(
plpData,
outcomeId = 2,
binary = TRUE,
firstExposureOnly = FALSE,
washoutPeriod = 0,
removeSubjectsWithPriorOutcome = FALSE,
priorOutcomeLookback = 99999,
requireTimeAtRisk = FALSE,
minTimeAtRisk = 0,
riskWindowStart = 0,
addExposureDaysToStart = FALSE,
riskWindowEnd = 365,
addExposureDaysToEnd = FALSE,
verbosity = "INFO"
)
As an example we will build a LRTorch model. We could specify the stacked autoencoder or the variational autoencoder to be used for reducing the feature dimension as an initial layer, but for this example we do not.
autoencoder <- FALSE
vae <- FALSE
We added a class_weight for imbalanced data, the default value 0 is the inverse ratio between negatives and positives,-1 applies focal loss.
class_weight <- 0
# Specify the settings for Logistics regression model using Torch in Python
model <- setLRTorch(autoencoder=autoencoder, vae=vae, class_weight=class_weight)
No we define our modelling parameters.
testFraction <- 0.2
testSplit <- 'person'
nfold <- 3
splitSeed <- 1000
And we train and internally validate the model.
results <- PatientLevelPrediction::runPlp(population = population,
plpData = plpData,
modelSettings = model,
testSplit=testSplit,
testFraction=testFraction,
nfold=nfold,
splitSeed=splitSeed)
Several architectures are implemented that can handle temporal data in PyTorch and R Keras.
We implemented the following convolutional models described in https://github.com/clinicalml/deepDiagnosis in CNNTorch:
Furthermore, we added the following achitectures:
| parameter | description |
|---|---|
| nbfilters | The number of convolution filters |
| epochs | The number of epochs |
| seed | Random seed |
| class_weight | The class weight used for imbalanced data (0: Inverse ratio between positives and negatives, -1: Focal loss, or number) |
The following recurrent neural network models are implemented in RNNTorch:
The following hyper-parameters can be set for these PyTorch models:
| parameter | description |
|---|---|
| hidden_size | The number of features in hidden state |
| epochs | The number of epochs |
| seed | Random seed |
| class_weight | The class weight used for imbalanced data (0: Inverse ratio between positives and negatives, -1: Focal loss, or number) |
The following temporal architectures as described in https://arxiv.org/pdf/1608.00647.pdf were implemented using R Keras:
Furthermore, a custom build RNN is added that uses a variational autoencoder.
Table 2: Temporal Deep Learning Models
| Model | Hyper-parameters |
|---|---|
| CovNN | batchSize (The number of samples to used in each batch during model training), outcomeWeight (The weight assigned to the outcome), lr (The learning rate), decay (The decay of the learning rate), dropout ([currently not used] the dropout rate for regularization), epochs (The number of times data is used to train the model, e.g., epoches=1 means data only used once to train), filters (The number of columns output by each convolution), kernelSize (The number of time dimensions used for each convolution), loss (The loss function implemented), seed (The random seed) |
| CovNN2 | batchSize (The number of samples to used in each batch during model training), outcomeWeight (The weight assigned to the outcome), lr (The learning rate), decay (The decay of the learning rate), dropout ([currently not used] the dropout rate for regularization), epochs (The number of times data is used to train the model, e.g., epoches=1 means data only used once to train), filters (The number of columns output by each convolution), kernelSize (The number of time dimensions used for each convolution), loss (The loss function implemented), seed (The random seed) |
| CIReNN | units (The number of units of RNN layer - as a list of vectors), recurrentDropout (The reccurrent dropout rate), layerDropout (The layer dropout rate), lr (Learning rate), decay (Learning rate decay over each update), outcomeWeight (The weight of the outcome class in the loss function), batchSize (The number of data points to use per training batch), epochs (Number of times to iterate over data set), earlyStoppingMinDelta (Minimum change in the monitored quantity to qualify as an improvement for early stopping, i.e. an absolute change of less than min_delta in loss of validation data, will count as no improvement), earlyStoppingPatience (Number of epochs with no improvement after which training will be stopped), seed (Random seed used by Deep Learning model) |
We will now show how to use the temporal models by using CNNTorch as an example.
You need to generate a population
and plpData
object as described in more detail in BuildingPredictiveModels
vignette.
Note that for these algorithms you need to extracted temporal data as described in the [FeatureExtraction vignette] (https://github.com/OHDSI/FeatureExtraction/blob/master/inst/doc/UsingFeatureExtraction.pdf) as follows:
settings <- createTemporalCovariateSettings(useConditionEraStart = FALSE,
useConditionEraOverlap = FALSE,
useConditionOccurrence = FALSE,
useConditionEraGroupStart = FALSE,
useConditionEraGroupOverlap = FALSE,
useDrugExposure = FALSE,
useDrugEraStart = FALSE,
useDrugEraOverlap = FALSE,
useMeasurement = FALSE,
useMeasurementValue = TRUE,
useMeasurementRangeGroup = FALSE,
useProcedureOccurrence = FALSE,
useDeviceExposure = FALSE,
useObservation = FALSE,
excludedCovariateConceptIds = c(316866),
addDescendantsToExclude = TRUE,
temporalStartDays = seq(from = -365,
to = -1, by = 12),
temporalEndDays = c(seq(from = -353,
to = 0, by = 12), 0))
plpData <- getPlpData(connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = "results",
cohortTable = "cohort",
cohortId = 11,
covariateSettings = settings,
outcomeDatabaseSchema = resultsDatabaseSchema,
outcomeTable = "cohort",
outcomeIds = 25,
cdmVersion = 5)
Each CNN/RNN has several hyper-parameters that can be set as shown in the Tables above, but for this example we take the defaults.
# specify the the CNN
model <- setCNNTorch(cnn_type='CNN')
Run the model training, for example with a testFraction = 0.2 and a split by person:
results <- PatientLevelPrediction::runPlp(population, plpData, model,
testSplit='person',
testFraction=0.2,
nfold=3,
splitSeed=1000)
Applying a Deep Learning is identical to the other models in the package:
# load the trained model
plpModel <- loadPlpModel(getwd(), "<your model>")
# load the new plpData (should have the same temporal features!) and create the population
plpData <- loadPlpData(getwd(), "<your data>")
populationSettings <- plpModel$populationSettings
populationSettings$plpData <- plpData
population <- do.call(createStudyPopulation, populationSettings)
# apply the trained model on the new data
validationResults <- applyModel(population, plpData, plpModel)
It is possible to add new architectures in our framework using PyTorch or R Keras. We are happy to help you with this, please post your questions on the issue tracker of the package.
Considerable work has been dedicated to provide the PatientLevelPrediction
package.
citation("PatientLevelPrediction")
##
## To cite PatientLevelPrediction in publications use:
##
## Reps JM, Schuemie MJ, Suchard MA, Ryan PB, Rijnbeek P (2018).
## "Design and implementation of a standardized framework to generate
## and evaluate patient-level prediction models using observational
## healthcare data." _Journal of the American Medical Informatics
## Association_, *25*(8), 969-975. <URL:
## https://doi.org/10.1093/jamia/ocy032>.
##
## A BibTeX entry for LaTeX users is
##
## @Article{,
## author = {J. M. Reps and M. J. Schuemie and M. A. Suchard and P. B. Ryan and P. Rijnbeek},
## title = {Design and implementation of a standardized framework to generate and evaluate patient-level prediction models using observational healthcare data},
## journal = {Journal of the American Medical Informatics Association},
## volume = {25},
## number = {8},
## pages = {969-975},
## year = {2018},
## url = {https://doi.org/10.1093/jamia/ocy032},
## }
Please reference this paper if you use the PLP Package in your work:


I noticed that there's not much info on A muscaria that comes from canada so i had to take the matters into my own hands to see if it was true about A muscaria being poisonous around here.
Last fall i was in my home town which is located in the peace region of BC (north eastern corner) i stumbled accross a beautiful patch of A muscaria, the red caps poped up everywhere in that poplar forest it was such a beautiful site i almost did'nt want to destroy it by picking them, but my curiousity got the better of me. I wandered around as the afternoon sun shon through the trees brightening each cap, i picking only the best ones and left others to respon next year.
I took them home and dryed them in the oven (this method suck) my friend and i each took 12 grams and made a tea. The effects were very mild but there was somthing, also we both felt very ill so we smoked some mj, but we had to smoke alot to take the feeling away. So its not true what they say, our Amanitas are not deadly but i would rater eat Psylocibe. Anyone like me who is interested the best time to pick here in BC is in the middle of september, and rather than drying in the oven i would say the best method is to let the wind do the work, i blame the weakness of the mushroom on the oven drying method. I think someone was full of it when they said that.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Exercise 3.2
Interest Only Calculator
Amount to Borrow
Interest Rate %
Length of Loan
Calculate
Total


The implementation dependent error codes returned by the I/O routines can be converted into the error classes defined in Table 11 . In addition, calls to routines in this chapter may raise errors in other MPI classes, such as MPI_ERR_TYPE.
| MPI_ERR_FILE | Invalid file handle |
|
MPI_ERR_NOT_SAME | Collective argument not identical on all processes, or collective routines called in a different order by different processes |
|
MPI_ERR_AMODE | Error related to the amode passed to MPI_FILE_OPEN |
|
MPI_ERR_UNSUPPORTED_DATAREP | Unsupported datarep passed to MPI_FILE_SET_VIEW |
|
MPI_ERR_UNSUPPORTED_OPERATION | Unsupported operation, such as seeking on a file which supports sequential access only |
|
MPI_ERR_NO_SUCH_FILE | File does not exist |
|
MPI_ERR_FILE_EXISTS | File exists |
|
MPI_ERR_BAD_FILE | Invalid file name (e.g., path name too long) |
|
MPI_ERR_ACCESS | Permission denied |
|
MPI_ERR_NO_SPACE | Not enough space |
|
MPI_ERR_QUOTA | Quota exceeded |
|
MPI_ERR_READ_ONLY | Read-only file or file system |
|
MPI_ERR_FILE_IN_USE | File operation could not be completed, as the file is currently open by some process |
|
MPI_ERR_DUP_DATAREP | Conversion functions could not be registered because a data representation identifier that was already defined was passed to MPI_REGISTER_DATAREP |
|
MPI_ERR_CONVERSION | An error occurred in a user supplied data conversion function. |
|
MPI_ERR_IO | Other I/O error |
|
|


Quick Finite State Machine
-
Quick Finite State Machine vs Boost Meta State Machine:
-
action driven instead of fsm driven data
-
logging policy integrated
-
policies: favor debug size, compilation time, execution speed (see comparison report)
-
quicker (execution speed policy)
-
faster compilation
-
less debug size
-
compile on gcc 3.4
-
all features may be only found on transition table
-
fsm and states are only abstraction
-
Fusion front end instead of EUML
-
state machine diagram script included
-
optional virtual interfaces
-
dispatcher integrated
-
no deep, shallow history
-
no serialization
-
Quick Finite State Machine vs Boost State Chart
back