Qpid Dispatch 1.13.0 Release Notes
Dispatch is a lightweight AMQP 1.0 message router. More about
Qpid
Dispatch.
For more information about this release, including download links and
documentation, see the release overview.
New features and improvements
- DISPATCH-1568 - Add unittest framework for testing C code
- DISPATCH-1633 - system_tests_sasl_plain intermittent test failure
- DISPATCH-1636 - Extract the version advertized in the Open performative by the peer router
- DISPATCH-1642 - Avoid extra search when adding address configs to parse tree
- DISPATCH-1646 - Unable to delete listener with http enabled
- DISPATCH-1656 - Allow user-configured connection properties in the Open performative
- DISPATCH-1667 - Increase minimum required LibWebSockets version from 2.1.0 to 2.4.2
- DISPATCH-1668 - Dockerfile instructions show how to use router debug core dump files
- DISPATCH-1675 - system_tests_stuck_deliveries failure with AttributeError: 'DelayedSettlementTest' object has no attribute 'proxy'",
- DISPATCH-1685 - Provide heap memory allocation wrappers that call abort() on failure to allocate
- DISPATCH-1688 - Scraper needs a way to inject debug statements into log data web page
- DISPATCH-1692 - Scraper improvements for sequence diagrams
- DISPATCH-1717 - Fallback_destination test improvements: mnemonic names, unique msg data and link names
- DISPATCH-1726 - Upgrade dependencies using dependabot PRs before the 1.13.0 release
- DISPATCH-1732 - segfault when connecting to multitenant listener with policy but no hostname in open
- DISPATCH-1739 - Use GitHub Actions w/ sharding and bubblewrap for some fast CI
Bugs fixed
- DISPATCH-960 - TCP port randomly assigned when using 'port: amqp' along with 'http: yes' on a listener
- DISPATCH-1444 - Top level Dockerfile fails to build on centos:latest
- DISPATCH-1494 - Qdstat heading for a memory display is Types
- DISPATCH-1505 - [tools] Add policy and vhost information to qdstat
- DISPATCH-1545 - Streaming deliveries can be delayed by head-of-line blocking on inter-router links
- DISPATCH-1637 - Adding new config address, autolinks and link routes become slower as more get added
- DISPATCH-1641 - If an oversize transfer is rejected then provide details in rejected outcome error field
- DISPATCH-1644 - Suppress cmake warning about LIBWEBSOCKETS
- DISPATCH-1645 - Max message size is demoted to INT from UINT64
- DISPATCH-1657 - system_tests_router_mesh ASAN failure
- DISPATCH-1658 - Receiver unable to receive messages on waypointed addresses
- DISPATCH-1661 - system_tests_edge_router fails with ASAN leak
- DISPATCH-1662 - system_tests_policy_oversize_compound fails with ASAN leak
- DISPATCH-1664 - test_verify_z_connection_stats failing in system_tests_policy
- DISPATCH-1669 - Compilation fails on macOS [-Werror,-Wformat]
- DISPATCH-1670 - system_tests_edge_router.LinkRouteProxyTest.test_50_link_topology reports many objects that remain allocated after test finishes
- DISPATCH-1676 - system_tests_policy failure on router shutdown
- DISPATCH-1682 - Optimize the parse tree match algorithm to avoid O(N) lookup
- DISPATCH-1690 - Pre-delivery messages leak on link close
- DISPATCH-1691 - Hash symbol in vhost hostname is treated as a comment delimiter
- DISPATCH-1693 - Edge router closes fallback receiver link when local primary receiver closes
- DISPATCH-1694 - sys_thread_self() returns NULL pointer if called by main process thread
- DISPATCH-1695 - Policy vhost groups description error
- DISPATCH-1703 - router drops TransactionalState on produced messages on link routes
- DISPATCH-1707 - Policy config file fails with cryptic error if trailing brace on wrong line
- DISPATCH-1708 - Fallback destination test receives messages on wrong receiver
- DISPATCH-1709 - Fallback destination rcvr on edge router is unaware that primary rcvr exited
- DISPATCH-1715 - [clang-10] error: variable length array folded to constant array as an extension
- DISPATCH-1716 - [clang] -fsanitize=address and -Wl,-z,defs compiler options are incompatible
- DISPATCH-1718 - Qdstat for policy and vhostgroups not backwards compatible
- DISPATCH-1721 - Qdstat table for vhostgroupsettings: too wide; missing default settings
- DISPATCH-1722 - system_tests_qdstat fails when checking for presence Worker Threads
- DISPATCH-1724 - Fallback destination fails when primary consumer is on an auto-link
- DISPATCH-1727 - Dispatch Console mixes usage of
npm
with yarn
- DISPATCH-1729 - Update console test file for DropdownMenu.js to pass required properties.
- DISPATCH-1730 - Revert console's @testing-library/react from 10.4.7 to 9.5.0
- DISPATCH-1733 - system_tests_open_properties failure due to qdr_connection_t leak
- DISPATCH-1737 - Policy config parse errors report wrong line and column numbers
- DISPATCH-1738 - system_tests_multicast failing on Ubuntu Focal
- DISPATCH-1741 - Update console dependency for yargs-parser to avoid security warning
Tasks
Apache Qpid, Messaging built on AMQP; Copyright © 2015
The Apache Software Foundation; Licensed under
the Apache
License, Version 2.0; Apache Qpid, Qpid, Qpid Proton,
Proton, Apache, the Apache feather logo, and the Apache Qpid
project logo are trademarks of The Apache Software
Foundation; All other marks mentioned may be trademarks or
registered trademarks of their respective owners


Move the blue square through maze onto the red square and collect the gold. Beware of deadly brown traps. Keep healthy with green squares. Try pink surprise!
Use one or more of the following commands: u - Up, d - Down, r - Right, l - Left.
For example, command "ddru" will move two cells down, then one to the right and one up.
The best Gold Runner can collect all the gold!
Collected gold
You have lives left
Congratulations GoldRunner!
Sorry for that! No more lives left. Try again.


Back
Log out
Borrower information
Name
Anna
Birthday
01.01
Credit Rating
🌟🌟🌟
University
CUHK
Student ID
1155132xxx
Major
Msc of Financial Technology


This time, it's not just a target - it's personal!
Explore more games
By continuing to navigate on this site, you accept the use of cookies by Ubisoft and its partners to offer advertising adapted to your interests, collect visit statistics and allow you to use the social network share buttons. To learn more and set your cookies.


Notebooks
Story: Parents instruct children how to get food, or, How D.H's father and mother instructed their children to get food
Parents instruct children how to get food, or, How D.H's father and mother instructed their children to get food
Title
Parents instruct children how to get food, or, How D.H's father and mother instructed their children to get food
Collection
Summary
Some Bushman children advised by their parents to be self-reliant in seeking food, in order to prepare themselves for the loss of their natural protectors. Related by Día!kwãin (L V.-6. 4404-4411 rev.-4413 rev.). This advice includes the waiting and watching for porcupine and other teachings relating to 'great things'. This is 'not a little story', but a 'great story', and is the story of the porcupine.
Comments
1) pp.4404v-4407v: see Things girls and youths must avoid (the rain's things), 2) This story is found in Book V-6
Contributors
Date
17 March 1875 (started)
Categories
Custom and daily life, Plants and animals
Keywords
food (parents teach self-reliance) , food (the finding of) , food (parents' instructions regarding) , food ('seeking feed ourselves') , teaching (by parents) , teaching (instruction regarding the finding of food) , teaching (of a 'great story', 'great things') , orphans (must 'seeking feed ourselves') , orphans (and the teaching of 'not a little story', 'a great story') , orphans ('being an orphan is a light thing', 'a great thing it is') , orphans (in the event of becoming) , orphans (the treatment of) , orphans (people drive them away) , orphans (and other people who are 'different') , orphans (the 'orphan state') , orphans (and their relations) , death (what parents teach their children in the event of their) , children (instructed by parents how to get food) , education (of children by their parents how to get food) , education (of a 'great story', 'great things') , porcupine (the story of the porcupine) , porcupine (watching and waiting for) , porcupine (parent's instruct children how to get food in the event of their orphaning) , porcupine (and 'not a little story', 'a great story') , story (parent's instruct children how to get food in the event of their orphaning) , story (and the teaching of 'not a little story', 'a great story', an ‘old story’)
Story Pages
4404-4411, 4410v-4413v


BlockKey Class
Definition
Line
15
of
cmsxk/Block.cm
Constructors & Destructor
public
nothrow
BlockKey
()
public
nothrow
BlockKey
(
int
blockNumber_,
int
fsNumber_)
Member Functions
public
nothrow
String
<
char
>
ToString
()
const
Member Variables
public
int
blockNumber
public
int
fsNumber
Constructor& Destructor Details
BlockKey Constructor
public
nothrow
BlockKey()
Definition
Line
17
of
cmsxk/Block.cm
BlockKey Constructor
public
nothrow
BlockKey(
int
blockNumber_,
int
fsNumber_)
Definition
Line
20
of
cmsxk/Block.cm
Member Function Details
ToString Member Function
public
nothrow
String
<
char
> ToString()
Definition
Line
23
of
cmsxk/Block.cm


|
Voxomap
A C++11 voxel container.
|
Voxomap is a container of voxels, it's a C++11 header only library. It was build to be used like a std container, it's templated on user data and it's possible to browse it with iterators.
The container is based on an octree and uses a structure in leaves of the tree to improve performance and memory footprint.
The library is based on an octree, it's a tree data structure in which each internal node has exactly eight children. Octrees are used to partition a three-dimensional space by recursively subdividing it into eight octants/nodes. The bottom level of the octree consists of leaf nodes that contain the voxels (user data). Octrees are the three-dimensional analog of quadtrees.
The leaf nodes of the VoxelOctree, that have size of 8, contain voxel container. A voxel container is a structure that contains voxels, it can contain 8x8x8(512) voxels. The voxel container fills all its octants/nodes, so like its container, it is axis aligned. The library allows to implement different type of voxel container. There are two implementations, but it's easy to create a new one that will better suit your needs.
This structure exists for improved performance and memory. This mixture between octree and array allows to take advantage of both structure without taking their disadvantages. Indeed, an octree has advantage to be dynamic and to not store empty space but can take lot of memory to store all its nodes and it's heavy to go through. An array, meanwhile, has advantage to store only user information (no nodes) and it's fast to go through but stores the empty space and is difficult to grow.
This structure doesn't store empty space (when no voxels, no voxel containers and no nodes), uses less nodes (voxel container inside node of size 8), it's easy to grow (advantage of a tree) and the performance for going through are very good (not so far from an array).
This structure is based on a fixed size 3D array that contains the user data. It's a very simple structure that is useful for high density of voxels.
Warning: For use this structure, the user data structure must override the boolean operator to know if it's an empty voxel or not.
This structure is a mix between a fixed size 3D array (like in ArrayContainer) and a dynamic array. Useful for little density of voxels.
The container uses 3 containers:
This structure is a wrapper on other voxel containers. It adds neighbor information inside voxels to allow the user to know the neighborhood of the voxels. The values of SideEnum are used to map the vicinity.
Warning: Since it is only a wrapper, it have to be used with another voxel container (like ArrayContainer or SparseContainer)
In this example, the blue voxel has 4 neighbors (at position x + 1, x - 1, y + 1 and z - 1).
So the side values are:
Super containers are similar to voxel containers but instead of containing voxels they contain voxel containers or super containers. Like voxel containers, the super containers contains 8x8x8 other containers and they fill all its octants/nodes.
There is two implemented super containers, ArraySuperContainer and SparseSuperContainer. They have the same characteristics as their voxel container counterpart (ArrayContainer and SparseContainer).
Like Voxel Container, this structure exists for improved performance, it allows to approach the performances of an array while keeping the advantage of the octree structure.
| Size of voxel | Number of voxels | ArrayContainer | SparseContainer |
|---|---|---|---|
| 1 byte | X | ||
| >= 2 bytes | <= 255 | X | |
| > 255 | X |
This comparative table is just here to give you an idea of what to use.
It's just a simple calculation:
Protocol:
Protocol:


Bootstrap v4.5.2
Bootstrap Lib
Bootstrap customization example to be reused in other framework applications.
Primary
Secondary
Success
Danger
Warning
Info
Light
Dark
Link


User-mode "drivers" mostly open hardware through a kernel-mode driver, often providing some service to user mode programs that is then translated into a call into a kernel mode driver. The most common example of this is a printer driver that translates device-independent calls into device-specific ones. Another example is a driver that simple provides a callable interface in order to virtualize direct hardware access from older DOS mode programs that were written expecting direct hardware access.
Plug and Plug drivers are device drivers in the most classical sense of the word -- they drive everything from video adapaters to mass storage devices. They integrate with the Power Manager and the Plug and Plug (PnP) Manager to provide the best possible user experience during installation and usage. Typically, Plug and Play is synonymous with the Windows Driver Model.
The Windows Driver Model (WDM) is the primary focus of this guide. The WDM is a strongly-recommended way to create device drivers that will work with 98/Me, 2000, and XP. It is supported through a framework provided by the XP Kernel (often called the Executive). WDM Drivers are implemented using a layered approach where each driver implements a layer that I/O requests and results must pass through on the journey from user-mode to physical hardware. Microsoft provides many facilities for driving devices under the WDM, and makes it difficult to successfully drive devices without the WDM. WDM drivers typically fall into three categories.
Bus drivers detect and manage devices on a physical bus plugged into the system. Typical buses include PCI, ISA, PCMIA, USB, and IEEE 1294 (Firewire). The primary role of a bus driver is to enumerate devices plugged in to the bus and inform the PnP Manager of their existence. It also typically manages power settings of the devices and the bus itself through the Power Manager.
Function drivers handle the operation of a particular device or type of device. A device is presented to the function driver from a bus driver via the PnP Manager. Function drivers typically know the most about the device they control and bear the closest resemblance to a non-layer monolithic device driver.
Filter drivers exist above or below function drivers. They filter information flowing from the function driver to the bus driver, and vice-versa. The I/O Subsystem of Windows XP is packet based, and filter drivers typically manipulate those packets as well as deleting and creating packets. For filtering input device drivers, filter drivers typically intercept the hooking mechanism in a plug and play IRP and install their own dispatch callback function.
There is one other classification of WDM drivers, in which three categories exist. Class Drivers are function drivers for devices that have a standardized interface, for which one driver can operate devices from a variety of manufacturers. Port drivers map I/O requests into a specific kind of port, such as RS232 or SCSI. Port drivers are typically a kernel-mode library that creates port-specific I/O requests from generic ones. Finally, Miniport drivers continue mapping where a Port driver leaves off -- miniport drivers take a port-type-specific I/O request and actually drive a device. Miniport drivers know things that are device specific such as which location on a serial interface handles a specific function of a device. It may be helpful to consider that a Port Driver + a Miniport Driver sum, in functionality, to a Function Driver.
Non-Plug and Play drivers are sometimes also referred to as Kernel-extensions. These often provide a new API to user-mode components to get a novel functionality out of kernel-mode services. These extensions add everything from encryption to new network protocol APIs.


Questions
I've come across a lot of really great questions while trying to find answers to my programming questions. These questions are clear, concise, specific, well researched and well thought out. There are thousands of questions asked on StackOverFlow and other related sites every single day. It seems like a lot of the questions that are asked are questions that have been asked many times before. A lot of these questions aren't very specific at all. In order for the question to be of use, you need to be as specific as possible. I think that the best piece of advice that I saw on the Stack OverFlow website was to pretend that you are asking a busy colleague. It says to try to sum up the problem as a single sentence.
A lot of the questions that didn't get answered were badly written, poorly thought out or had been answered many times already. I could tell that the author didn't spend too much time trying to find the answer himself. Sometimes the questions even ask the answerer to do the bulk of the work! People get much better answers if they ask better questions and copy in code to prove that you are at least trying to solve your coding problem.
- Pretend you are asking a busy colleague, so keep it short
- Ask one thing at a time
- Follow general questions with specific questions
- Don't ask yes or no questions
- Don't interrupt and listen fully to what they are saying
- Wait in silence even after they finish explain
Learning how to ask questions properly is a vital skill to hone when learning how to code. It's also incredibly helpful to learn how to ask questions in person and online. You many not have constant exposure to either, so you need to learn how to formulate a question differently. Learning how to code requires the help of an entire community.


Applying Bag of Words and Word2Vec models on Reuters-21578 Dataset
Introduction
In this post, I will showcase the steps I took to create a continuous vector space based on the corpora included in the famous Reuters-21578 dataset (hereafter ‘reuters dataset’). The reuters dataset is a tagged text corpora with news excerpts from Reuters newswire in 1987. Although the contents of the news is somewhat outdated, the topic labels provided in this dataset is widely used as a benchmark for supervised learning tasks that involve natural language processing (NLP).
Word2Vec, among other word embedding models, is a neural network model that aims to generate numerical feature vectors for words in a way that maintains the relative meanings of the words in the mapped vectors. It provides a reliable method to reduce the feature dimensionality of the data, which is the biggest challenge for traditional NLP models such as the Bag of Words (BOW) model.
BOW, on the other hand, is the traditional and established approach in text mining. The model deconstructs text into a list of words with either frequency or dummy checklist, hence creating a “bag of words” as a result. Although this approach is widely used as the beginner model for text-related projects, it has significant drawbacks:
- The sequencing and relative positioning of the words are largely ignored
- The resulted features are sparse, making it harder to build predictive models with
Although these two drawbacks could be fixed with n-gram and dimensionality reduction, it is an analyst’s dream to have a model like Word2Vec that gives you sensible vector representation of words that’s useful for semantic analysis.
Load Reuters Dataset
Before applying the models, I will generate a dataframe with the corpora. The first step is to download the reuters data and check out what is inside.
import numpy as np
import pandas as pd
import nltk
import re
from nltk.corpus import reuters
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from collections import Counter
# quick summary of the reuters corpus
print(">>> The reuters corpus has {} tags".format(len(reuters.categories())))
print(">>> The reuters corpus has {} documents".format(len(reuters.fileids())))
>>> The reuters corpus has 90 tags
>>> The reuters corpus has 10788 documents
The reuters
from nltk
package comes with its specific sets of methods, making it hard to select and filter desired corpora. For my purpose in this report, I will only select 2 popular tags out of the 90 tags included in this corpora. Therefore, my next step is to generate a frequency table that summarizes the tags.
# create counter to summarize
categories = []
file_count = []
# count each tag's number of documents
for i in reuters.categories():
"""print("$ There are {} documents included in topic \"{}\""
.format(len(reuters.fileids(i)), i))"""
file_count.append(len(reuters.fileids(i)))
categories.append(i)
# create a dataframe out of the counts
df = pd.DataFrame(
{'categories': categories, "file_count": file_count}) \
.sort_values('file_count', ascending=False)
print(df.head())
categories file_count
21 earn 3964
0 acq 2369
46 money-fx 717
26 grain 582
17 crude 578
I decide to chose the second and third tags on this top tags list, since the first earn tag is most likely the highly-standardized news pieces with earnings reports.
# Select documents that only contains top two labels with most documents
cat_start = 1
category_filter = df.iloc[cat_start:cat_end + 1, 0].values.tolist()
print(f">>> The following categories are selected for the analysis: \
{category_filter}")
>>> The following categories are selected for the analysis: ['acq', 'money-fx']
I then apply my tag filter on the text corpora to select text that have either the acq
tag or the money-fx
tag. The reuters data comes with a split of training and testing itself, so I will stick with its original split.
# select fileid with the category filter
doc_list = np.array(reuters.fileids(category_filter))
doc_list = doc_list[doc_list != 'training/3267']
test_doc = doc_list[['test' in x for x in doc_list]]
print(">>> test_doc is created with following document names: {} ...".format(test_doc[0:5]))
train_doc = doc_list[['training' in x for x in doc_list]]
print(">>> train_doc is created with following document names: {} ...".format(train_doc[0:5]))
test_corpus = [" ".join([t for t in reuters.words(test_doc[t])])
for t in range(len(test_doc))]
print(">>> test_corpus is created, the first line is: {} ...".format(test_corpus[0][:100]))
train_corpus = [" ".join([t for t in reuters.words(train_doc[t])])
for t in range(len(train_doc))]
print(">>> train_corpus is created, the first line is: {} ...".format(train_corpus[0][:100]))
>>> test_doc is created with following document names: ['test/14843' 'test/14849' 'test/14852' 'test/14861' 'test/14865'] ...
>>> train_doc is created with following document names: ['training/10' 'training/1000' 'training/10005' 'training/10018'
'training/10025'] ...
>>> test_corpus is created, the first line is: SUMITOMO BANK AIMS AT QUICK RECOVERY FROM MERGER Sumitomo Bank Ltd & lt ; SUMI . T > is certain to l ...
>>> train_corpus is created, the first line is: COMPUTER TERMINAL SYSTEMS & lt ; CPML > COMPLETES SALE Computer Terminal Systems Inc said it has com ...
Now that I have the corpora in place, it’s time to clean up the text to reduce the noice from non-text elements. I have stored my text-cleaning functions in another module called text_clean.py
and I will import it to clean up the text. My module document as well as all codes related to this project can be found at my GitHub Repo here.
import text_clean as tc
# create clean corpus for word2vec approach
test_clean_string = tc.clean_corpus(test_corpus)
train_clean_string = tc.clean_corpus(train_corpus)
print('>>> The first few words from cleaned test_clean_string is: {}'.format(test_clean_string[0][:100]))
print('>>> The first few words from cleaned train_clean_string is: {}'.format(train_clean_string[0][:100]))
>>>> response cleaning initiated
>>>> cleaning response #500 out of 898
>>>> response cleaning initiated
>>>> cleaning response #500 out of 2186
>>>> cleaning response #1000 out of 2186
>>>> cleaning response #1500 out of 2186
>>>> cleaning response #2000 out of 2186
>>> The first few words from cleaned test_clean_string is: sumitomo bank aim quick recovery merger sumitomo bank ltd lt sumi certain lose status japan profitab
>>> The first few words from cleaned train_clean_string is: computer terminal systems lt cpml complete sale computer terminal systems inc say complete sale shar
Glimpse of BOW model
After the text is cleaned, I can now apply the BOW model on the corpora. The BOW is basically a frequency Counter
, so I have written a function to get BOW from the corpora in my text_clean.py
module.
# create clean corpus for bow approach
test_clean_token = tc.clean_corpus(test_corpus, string_line=False)
train_clean_token = tc.clean_corpus(train_corpus, string_line=False)
# quick look at the word frequency
test_bow, test_word_freq = tc.get_bow(test_clean_token)
train_bow, train_word_freq = tc.get_bow(train_clean_token)
>>>> response cleaning initiated
>>>> cleaning response #500 out of 898
>>>> response cleaning initiated
>>>> cleaning response #500 out of 2186
>>>> cleaning response #1000 out of 2186
>>>> cleaning response #1500 out of 2186
>>>> cleaning response #2000 out of 2186
This corpus has 7126 key words, and the 10 most frequent words are: [('say', 2976), ('lt', 1112), ('share', 1067), ('dlrs', 921), ('company', 886), ('pct', 758), ('mln', 755), ('inc', 637), ('bank', 505), ('corp', 500)]
This corpus has 11042 key words, and the 10 most frequent words are: [('say', 7388), ('lt', 2802), ('share', 2306), ('dlrs', 2247), ('mln', 2172), ('pct', 2051), ('bank', 1983), ('company', 1942), ('inc', 1469), ('u', 1291)]
The BOW is a frequency table that records the word frequencies for each news piece in the corpora. If I turn it into a table view, it is clear that the most of the columns will be NaN
due to the sparse nature of a BOW model. In fact, for the few rows of the test_bow
table, all displayed cells below are NaN. Tables like this will make most of the data science models imprecise when we conduct predictive analysis.
print(pd.DataFrame(test_bow).head())
aabex aame aar ab abandon abate abatement abboud abegglen abeles \
0 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
2 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
3 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
4 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
... zellerbach zenex zinn zoete zond zondervan zone zoran \
0 ... NaN NaN NaN NaN NaN NaN NaN NaN
1 ... NaN NaN NaN NaN NaN NaN NaN NaN
2 ... NaN NaN NaN NaN NaN NaN NaN NaN
3 ... NaN NaN NaN NaN NaN NaN NaN NaN
4 ... NaN NaN NaN NaN NaN NaN NaN NaN
zurich zwermann
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 NaN NaN
4 NaN NaN
[5 rows x 7126 columns]
The typical way to reduce the noise in BOW models is to use dimensionality reduction methods, such as Latent Semantic Indexing (LSA), Random Projections (RP), Latent Dirichlet Allocation (LDA), or Hierachical Dirichlet Process (HDP).
Glimpse of Word2Vec Model
The alternative, of course, is to use the famous word2vec algorithm to generate continous numeric vectors. I will use gensim
package to conduct this task. After I train the model with the reuters corpora, I get a dictionary that maps a numeric vector to each word that appears in the corpora.
import gensim
import logging
# set up logging for gensim training
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
model = gensim.models.Word2Vec(train_clean_token, min_count=1, workers=2)
2017-10-17 10:41:29,134 : INFO : collecting all words and their counts
2017-10-17 10:41:29,135 : INFO : PROGRESS: at sentence #0, processed 0 words, keeping 0 word types
2017-10-17 10:41:29,197 : INFO : collected 11042 word types from a corpus of 191770 raw words and 2186 sentences
2017-10-17 10:41:29,198 : INFO : Loading a fresh vocabulary
2017-10-17 10:41:29,235 : INFO : min_count=1 retains 11042 unique words (100% of original 11042, drops 0)
2017-10-17 10:41:29,236 : INFO : min_count=1 leaves 191770 word corpus (100% of original 191770, drops 0)
2017-10-17 10:41:29,295 : INFO : deleting the raw counts dictionary of 11042 items
2017-10-17 10:41:29,297 : INFO : sample=0.001 downsamples 40 most-common words
2017-10-17 10:41:29,298 : INFO : downsampling leaves estimated 169461 word corpus (88.4% of prior 191770)
2017-10-17 10:41:29,300 : INFO : estimated required memory for 11042 words and 100 dimensions: 14354600 bytes
2017-10-17 10:41:29,375 : INFO : resetting layer weights
2017-10-17 10:41:29,533 : INFO : training model with 2 workers on 11042 vocabulary and 100 features, using sg=0 hs=0 sample=0.001 negative=5 window=5
2017-10-17 10:41:30,539 : INFO : PROGRESS: at 80.76% examples, 681629 words/s, in_qsize 3, out_qsize 0
2017-10-17 10:41:30,878 : INFO : worker thread finished; awaiting finish of 1 more threads
2017-10-17 10:41:30,887 : INFO : worker thread finished; awaiting finish of 0 more threads
2017-10-17 10:41:30,888 : INFO : training on 958850 raw words (846962 effective words) took 1.4s, 626379 effective words/s
With the model, I can get the numeric representation of any word that’s included in the model’s dictionary, and even quickly calculate the “similarity” between two words.
print(">>> Printing the vector of 'inc': {} ...".format(model['inc'][:10]))
print(">>> Printing the similarity between 'inc' and 'love': {}"\
.format(model.wv.similarity('inc', 'love')))
print(">>> Printing the similarity between 'inc' and 'company': {}"\
.format(model.wv.similarity('inc', 'company')))
>>> Printing the vector of 'inc': [ 0.78641725 -0.81131667 2.96111465 -1.71037292 1.00312221 0.0688597
0.13069828 0.99924785 -0.35323438 0.14066967] ...
>>> Printing the similarity between 'inc' and 'love': 0.8529129076656723
>>> Printing the similarity between 'inc' and 'company': 0.9254433388270853
inc and company appears to be more similar than inc and love. After I get the vector representation of each word, I can calculate the vector representation of each news piece by simply getting the vector mean of all words included in that news piece. There certainly are more advanced aggregation methods, but for this practice I will use the most straightforward way. Another thing worth noticing is that I need to assign an all-zero vector if a word is not included in the dictionary of the Word2Vec model.
I also created a module for the matrix aggregation in my GitHub repo here; so I simply import the function get_doc_matrix
and calculate the document vectors.
from w2v_cal import get_doc_matrix
test_matrix = get_doc_matrix(model, test_clean_token)
train_matrix = get_doc_matrix(model, train_clean_token)
Be noted that my word2vec
model was trained with the train_clean_token
corpus, but I use the model on the test_clean_token
here. I did it on purpose because in real-life situation, you won’t know your test set when you train the model. If you need to evaluate how accurate the model can be, you need to separate the train and test even on the word embedding stage.
A work-around that I’ve thought of is to update the word2vec
model on the fly by feeding it the new corpora that come with the new documents: in this way I only update the model with the information that I know of - the test document I’m dealing with and all the train documents. I will further elaborate on this idea in my future posts about word embedding applications.
print(pd.DataFrame(test_matrix).head())
0 1 2 3 4 5 6 \
0 0.147100 -0.175438 0.888369 -0.069528 0.033833 -0.013307 0.233525
1 0.042170 -0.163114 0.978680 0.227916 -0.142440 -0.083064 0.235953
2 0.155263 -0.208363 1.048186 -0.157641 0.127218 -0.066839 0.140428
3 -0.023057 -0.217250 1.123171 0.460213 -0.346473 -0.105230 0.137149
4 0.183727 -0.297932 1.154441 -0.333167 0.194415 -0.019180 0.009379
7 8 9 ... 90 91 92 \
0 0.274196 -0.175343 -0.073920 ... 0.069914 -0.158157 0.241313
1 0.349826 -0.203713 -0.163635 ... 0.014871 -0.315029 0.215814
2 0.388008 -0.176918 -0.088959 ... 0.181733 -0.196467 0.211149
3 0.438802 -0.264249 -0.317894 ... -0.017868 -0.349207 0.047567
4 0.449627 -0.152873 -0.030410 ... 0.272388 -0.197652 0.166376
93 94 95 96 97 98 99
0 -0.301072 -0.613152 -0.001587 0.609080 0.174361 -0.124058 -0.203552
1 -0.306695 -0.832693 0.124513 0.852931 0.039255 -0.264621 -0.344080
2 -0.378385 -0.608279 -0.048504 0.716636 0.140785 -0.093196 -0.194501
3 -0.359221 -0.989569 0.082096 1.062137 -0.133572 -0.353757 -0.346747
4 -0.503684 -0.586876 -0.133392 0.807204 0.136802 -0.059075 -0.122065
[5 rows x 100 columns]
A glimpse of the resulted word matrix indicates that the dataset is now filled with continuous numeric values. I can now use more models to predict the labels of these news pieces. I will test the effectiveness of these two models in my upcoming posts.
Leave a Comment


Percolation is a scientific model that is used to analyze the connectivity of systems. For example, it can be used to analyze if a porous landscape with water on the surface will eventually allow the water to drain through to the bottom. It can be used to analyze if oil would be able to reach the surface in a similar manner. The idea of the model is to analyze what conditions are necessary for the system to percolate (i.e. let the water or oil through).
The current assignment will allow students to apply the union-find data structure to solve this problem. The system will be represented as a N-by-N grid where each cell can be in one of 3 states: blocked (black), open (white) or full (blue). A grid where percolation has been achieved will have a path of full cells from the surface to the bottom.
Percolation
that complies with the following interface:
public Percolation(int n)
: Create a new n by n grid where all cells are initially blocked
public void open(int x, int y)
: Open the site at coordinate (x,y), where x represents the horizontal axis and y the vertical one.
For consistency purposes, (0,0) will be the bottom-left cell of the grid and (n-1,n-1) will be on the top-right.
The graphical capabilities discussed later assume a similar convention.
public boolean isOpen(int x, int y)
: Returns true if cell (x,y) is open due to a previous call to open(int x, int y)
public boolean isFull(int x, int y)
: Returns true if there is a path from cell (x,y) to the surface (i.e. there is percolation up to this cell)
public boolean percolates()
: Analyzes the entire grid and returns true if the whole system percolates
public static void main(String[] args)
: Create a main method that reads a description of a grid from standard input (using StdIn.java
)
and validates if the system described percolates or not, printing to standard output a simple "Yes" or "No" answer (using StdOut.java).
%java Percolation < gridpercolates.txt Yes %java Percolation < griddoesntpercolate.txt NoThe input file format is simple: the first line contains the value of n, as in the Percolation constructor parameter, and a variable number of extra lines, each containing a cell coordinate, following the format "<x-value><space><y-value>". The program should open the sites in the same order they appear in the file and print the final result after processing all of them. Sample files can be found here.
PercolationVisualizer.java
that receives an input file the same way Percolation.java
does but, instead of displaying a Yes/No answer,
it will graphically show the process of opening each of the sites one after another similar to this example.
The call to that program should be %java PercolationVisualizer < input.txt
In order to produce the visualization, students can use the API provided through StdDraw.java in the book standard library. By default, all drawings on the canvas are based on unit-square coordinate values, which means that all coordinate values go from 0 to 1 (0,0 bottom-left corner and 1,1 top-right). It is suggested that these coordinate boundaries are used and that cell sizes be adjusted to fractions between 0 and 1 depending on the grid size.
For grading purposes only small-sized grids will be used (up to N=20) thus, although Percolation.java should handle any grid size theoretically, the visualization will only be checked using that size range. It is suggested that a window size of around 600x600 is used.
To do so, create a program called PercolationStats.java
that will generate systems randomly connected that can be used to estimate p*. More specifically, do the following:
StdRandom.uniform
)
StdStats.stddev(double[])
.
The main method in PercolationStats will receive three command line parameters, N, T and type, that will indicate the program to perform T repetitions of the previous process for a grid of size N-by-N. The type parameter will be a string, either slow or fast, which will determine the type of union method to be used. Algorithm 1.5 mentions 3 types of modifications that can be used to implement the union-find data structure. For this project, students will need to take into account quick find (slow) and the weighted quick union (fast). Depending on which parameter is given to the program a different implementation of the data structure should be used and it should reflect a distinct performance change from one to the other.
The output of the program should include the mean percolation threshold and the corresponding standard deviation. Additionally, it should output the total execution time of all experiments, the mean time for each experiment and its standard deviation (you can use Stopwatch.java). The following example shows a call that intends to run 50 simulations with a grid size of 20, using the weighted quick union method (the values after the = should be actual values in your program):
%java PercolationStats 20 50 fast mean threshold=the_threshold_value std dev=the_threshold_stddev time=total_time_in_seconds mean time=mean_time_in_seconds stddev time=stddev_time_in_second
PercolationStats.java
, analyze the consequences of using different values of N and each of the two modifications to the data structure. Make a qualitative analysis of using T=30 and N={10,25,50,100,250,500}, for each of the two methods. What differences can be found in terms of execution time? What is the behavior of the estimates of p*?
Create a PDF file named yourName_yourSurname.pdf with your analysis and submit it along with your source code. Your report should include the following two plots:
turnin
will be used to submit assignments.
Create a folder where you will include all source code and libraries used. The report should be included in that folder, too. Finally, provide a README
file with your name, instructions to compile and run your code (Please do not use absolute paths, or at least tell how to modify it to compile without problems) and anything you would like us to know about your program (like errors, special conditions, etc).
After logging into data.cs.purdue.edu
, please follow these steps to submit your assignment:
yourName_yourSurname
and copy all of your files there.
/homes/jsmith/john_smith
, go to /homes/jsmith
), execute the following command:
%turnin -c cs251 -p project1 your_folder_name(e.g.,
turnin -c cs251 -p project1 john_smith
) Keep in mind that old submissions are overwritten with new ones whenever you execute this command.
You can verify the contents of your submission by executing the following command:
%turnin -v -c cs251 -p project1Do not forget the -v flag here, as otherwise your submission would be replaced with an empty one.
Since you will need to use 2 implementations of union-find, for the purposes of grading, submit your Percolation.java
file using the weighted quick union find implementation.


About the Collection
Search for Videos
Video Index
Jim Henson at UMD
Jim Henson's doodle for Beaker from
The Muppet Show
and movies.


Visualiser
Visualiser
Select a Country
New Zealand
Cook Islands
Other
Select number of populations
1
2
3
4
Select a geographic type
National
Sub-National
Select a sub-national type
Regional
TLA
DHB
Rohe
Select an age grouping
Total
5-year bands
Other
Select a standard type
External
Internal
Select a standard type
WHO
Segi
Maori 13 Census
Standard population
Population 1 (default)
Standard population
Population 1 (default)
Population 2
Standard population
Population 1 (default)
Population 2
Population 3
Standard population
Population 1 (default)
Population 2
Population 3
Population 4
Select a baseline
Population 1 (default)
Select a baseline
Population 1 (default)
Population 2
Select a baseline
Population 1 (default)
Population 2
Population 3
Select a baseline
Population 1 (default)
Population 2
Population 3
Population 4
Population 1:
Select a mortality cause
Total Mortality
Gastric Death
Gastric Incidence
Self-harm X60-X84
Select an ethnicity
Total
Maori
Non-Maori
Select a gender
Total
Male
Female
Population 2:
Select a mortality cause
Total Mortality
Gastric Death
Gastric Incidence
Select an ethnicity
Total
Maori
Non-Maori
Select a gender
Total
Male
Female
Population 3:
Select a mortality cause
Total Mortality
Gastric Death
Gastric Incidence
Select an ethnicity
Total
Maori
Non-Maori
Select a gender
Total
Male
Female
Population 4:
Select a mortality cause
Total Mortality
Gastric Death
Gastric Incidence
Select an ethnicity
Total
Maori
Non-Maori
Select a gender
Total
Male
Female
Table
Graph 1
Graph 2


Animating a Hyperspaec Effect (with Realtime Motion Blur!)
by James Xwintermute digital writes:
One of the coolest effects you can get in EEVEE is motion blur, in realtime! It's also lightning fast to render, and we'll use that to make a hyperspace-jump effect in Blender.
Here's the text-based version of this tutorial.


I want the Tiny Studio for my {{bookingRequest.eventType}}
{{/if}} {{#if equals currentEventType eventTypes.business}}I want the Tiny Studio for my {{bookingRequest.eventType}}
{{/if}} {{#if equals currentEventType eventTypes.event}}I want the Tiny Studio for my {{bookingRequest.eventType}}
{{/if}} {{#if hasBeenToStep2}}We make {{bookingRequest.incomeSliderComputed}} per year
This event is for an estimated {{bookingRequest.attendanceSliderComputed}} makers
The event lasts {{bookingRequest.timeSliderComputed}} hours
{{/if}} {{#if bookingRequest.eventName}}Event name: {{bookingRequest.eventName}}
{{else}} {{/if}} {{#if bookingRequest.eventDate}}Date of the event: {{bookingRequest.eventDate}}
{{else}} {{/if}} {{#if bookingRequest.ageRange}}The target age is {{toLowerCase bookingRequest.ageRange}}
{{else}} {{/if}} {{#if bookingRequest.contactEmail}}Contact email: {{#unless matchesEmailRegex bookingRequest.contactEmail}} {{bookingRequest.contactEmail}} {{else}} {{bookingRequest.contactEmail}} {{/unless}}
{{else}} {{/if}}Check your email - we will be in touch very shortly. In the meantime, please reach out to us at<EMAIL_ADDRESS>if you have any questions.


{% extends "themes/" + sysSettings.systemTheme + "/layout.html" %} {% from "security/_macros.html" import render_field_with_errors, render_field %} {% from "security/custom_macros.html" import fields_errors %} {% block head %}


# import 'macro/forms.html' as forms
# include 'admin/populate/bit/_user.html'
# include 'admin/populate/bit/_collection.html'
# include 'admin/populate/bit/_collection_user.html'
# include 'admin/populate/bit/_tag.html'
# include 'admin/populate/bit/_icon.html'
# include 'admin/populate/bit/_waypoint.html'


No search term entered
No stored slots serial number contain: {{searchTerm}}
Serial Number: {{slot.SerialNumber}}
Slot #:{{slot?.SlotNumber}} |Manufacturer: {{slot.DisplayManufacturer}} |Cabinet Model:
{{slot.CabinetModel}} |Game Chip:{{slot.GameChip}}
{{slot.WorkflowState}}


--- layout: post title: Some free hours! *Click* category: - Analog - BlackAndWhite - Street Photos tags: - 35mm - antónio capelo - antoniocapelo - BlackAndWhite - canonet ql17 - capelo - fotografia - porto - portugal - ql17 - shutter hell up - street - tri-x status: publish type: post published: true meta: _edit_last: '1' ---
Got some free time between college tests and deadlines, so here it is, my newest roll. The camera used was the lovely Canonet QL17 loaded with a Kodak Tri-X 400! Ah, as you may notice, I changed the blog visual to a simpler look, the autofocus theme was very good but I felt the need to go basic ;)
Dog or cotton candy?
The Stamp Forum
Vandoma Regular
No street for two men
Plaza
Big Couple
Checking her order
Analog
Checking the real *street* performer
A lifetime’s not enough
Mocking
Late!
Subway nap
The Paper
domesticated & civilized
new species appear
“smoke gets in your eyes”
kick / push
Boavista
Late afternoon ride
bokeh bag (…more than kodak)
Hope you like the new look of the blog! The “real” site is coming! :)
More rolls to come,
António Capelo


Methods
extractOnionURI(contentString, fromEntry, isHtmlString) → {Array.<ParseResult>}
Extract all .onion URI within the string
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
contentString |
string | String (typically a HTML or JSON) from which .onion uris should be extracted. | |
fromEntry |
DbResult | In order to construct the full URL from relative URLS, we need to pass in the current db entry, where the content was fetched for. | |
isHtmlString |
boolean | true | Indicate if input is an html string. Used for initialization and if later on more mime types can be used it will be extended to cover this. |
Returns:
A list of matched .onion urls and possible
subdomains as well as the paths and possible arguments
(which are counted towards the path in this case)
- Type
- Array.<ParseResult>
(async) extractText(rawString, mimeType) → {Promise}
Extracts text from the given string using textract. This needs
to know the mimetype, in order to select the correct extractor.
Since the mimeType is stored within the database, this is not an issue
Parameters:
| Name | Type | Description |
|---|---|---|
rawString |
string | The string from which the text should be extracted |
mimeType |
string | The mime type of the passed string. This will usually be a text/html or plain text format |
Returns:
Resolved with the extracted text, otherwise
rejected with a string error message
- Type
- Promise
removeBase64Media(stringToTest) → {string}
This RegEx can be used to match or test strings if they contain base64
encoded data. Credits to @bgrins (GitHub)
Direct Link: https://gist.github.com/bgrins/6194623
Parameters:
| Name | Type | Description |
|---|---|---|
stringToTest |
string | This string will be tested against the regex. |
Returns:
The return value indicates whether the passed string
contained any base64 data (true) or not (false).
- Type
- string


| Skills | Level |
| Total | 933 |
| Agility | 1 |
| Attack | 64 |
| Construction | 1 |
| Cooking | 63 |
| Crafting | 70 |
| Defense | 69 |
| Farming | 1 |
| Firemaking | 60 |
| Fishing | 61 |
| Fletching | 1 |
| Herblore | 1 |
| Hitpoints | 67 |
| Hunter | 1 |
| Magic | 59 |
| Mining | 73 |
| Prayer | 53 |
| Ranged | 50 |
| Runecraft | 50 |
| Slayer | 1 |
| Smithing | 62 |
| Strength | 64 |
| Thieving | 1 |
| Woodcutting | 60 |


{% extends 'base.html' %} {% block content %}
There are no proposals now.
{{ proposal.proposal }}
{{ current_proposal.proposal }}


The <md-slider>
component allows the user to choose from a range of values.
As per the Material Design spec
the slider is in the accent color by default. The primary color palette may be used with
the md-primary
class.
The slider has two modes:
To enable discrete mode, add the md-discrete
attribute to a slider
and use the step
attribute to change the distance between
values the user is allowed to pick.
When using the keyboard:
| Parameter | Type | Description |
|---|---|---|
* ng-model
expression
|
expression |
Assignable angular expression to be data-bound.
The expression should evaluate to a |
ng-disabled
expression
|
expression |
If this expression evaluates as truthy, the slider will be disabled. |
ng-readonly
expression
|
expression |
If this expression evaluates as truthy, the slider will be in read only mode. |
md-discrete
boolean
|
boolean |
If this attribute exists during initialization, enable discrete
mode. Defaults to |
md-vertical
boolean
|
boolean |
If this attribute exists during initialization, enable vertical
orientation mode. Defaults to |
md-invert
boolean
|
boolean |
If this attribute exists during initialization, enable inverted mode.
Defaults to |
step
number
|
number |
The distance between values the user is allowed to pick. Defaults to |
min
number
|
number |
The minimum value the user is allowed to pick. Defaults to |
max
number
|
number |
The maximum value the user is allowed to pick. Defaults to |
round
number
|
number |
The amount of numbers after the decimal point. The maximum is 6 to
prevent scientific notation. Defaults to |


To view your BIM 360 Accounts files on this app please authorize my Forge Client ID with your BIM 360 Docs Account.
Use this as Forge Client ID:
To access your BIM 360 Docs files with this app, you need to connect your BIM 360 account with the app.
Congratulations! You can now access your BIM 360 Docs files.


Omitting and ending tag like

makes a mess of the page.
Some browsers center important headings; others do not.
Strictly speaking, whether a heading is centered or not
is a formatting decision and should be left to the browser.
The

...

tags describe the function
of the text they contain.
However, web authors like to have some control over the
presentation of their content.
To center a heading or a paragraph (or anything else) use these tags:

 stuff to be centered

div stands for "division".
The align="center"
describes what type of division you want.
You can also have align="right"
and align="left"
.
Here is a web page.
Insert some div
tags to center the heading and the second paragraph.
(Remember that you can use "copy", "cut", and "paste" from the
edit menu of your browser with the text in the box.)


| bootstrap
|
https://getbootstrap.com/
|
| bootstrap-colorpicker
|
https://itsjavi.com/bootstrap-colorpicker/
|
| bootstrap-datepicker
|
https://bootstrap-datepicker.readthedocs.io/en/stable/
|
| bootstrap-duallistbox
|
http://www.virtuosoft.eu/code/bootstrap-duallistbox/
|
| bootstrap-material-datetimepicker
|
https://github.com/T00rk/bootstrap-material-datetimepicker
|
| bootstrap-switch
|
https://github.com/Bttstrp/bootstrap-switch/releases/tag/v3.3.4
|
| bootstrap-touchspin
|
https://www.virtuosoft.eu/code/bootstrap-touchspin/
|
| chart.js
|
https://www.chartjs.org/
|
| chartist
|
https://gionkunz.github.io/chartist-js/
|
| chartist-plugin-tooltips
|
https://github.com/gionkunz/chartist-js
|
| ckeditor
|
https://ckeditor.com/
|
| clockpicker
|
http://weareoutman.github.io/clockpicker/
|
| cropper
|
https://fengyuanchen.github.io/cropper/
|
| datatables
|
https://datatables.net/
|
| daterangepicker
|
http://www.daterangepicker.com/
|
| dragula
|
https://bevacqua.github.io/dragula/
|
| dropzone
|
https://www.dropzonejs.com/
|
| peity
|
https://benpickles.github.io/peity/
|
| knob
|
http://anthonyterrien.com/demo/knob/
|
| sparkline
|
https://omnipotent.net/jquery.sparkline/#s-about
|
| echarts
|
https://echarts.apache.org/en/index.html
|
| flot
|
https://github.com/flot/flot#readme
|
| bootstrap-treeview
|
https://jonmiles.github.io/bootstrap-treeview/
|
| select2
|
https://select2.org/
|
| typeahead.js
|
https://twitter.github.io/typeahead.js/
|
| footable
|
https://fooplugins.com/footable/
|
| fullcalendar
|
https://fullcalendar.io/
|
| gaugeJS
|
http://bernii.github.io/gauge.js/
|
| gmaps
|
https://hpneo.dev/gmaps/
|
| inputmask
|
https://github.com/RobinHerbots/Inputmask
|
| jquery
|
https://api.jquery.com/
|
| jquery.flot.tooltip
|
http://www.flotcharts.org/
|
| jquery.repeater
|
https://github.com/DubFriend/jquery.repeater
|
| jquery-asColor
|
https://github.com/thecreation/jquery-asColor
|
| jquery-asColorPicker
|
https://github.com/thecreation/jquery-asColorPicker
|
| jquery-asGradient
|
https://github.com/thecreation/jquery-asGradient
|
| jquery-sessiontimeout
|
https://github.com/travishorn/jquery-sessionTimeout
|
| jquery-steps
|
http://www.jquery-steps.com/
|
| jquery-validation
|
https://jqueryvalidation.org/
|
| jsgrid
|
http://js-grid.com/
|
| jvectormap
|
http://jvectormap.com/
|
| magnific-popup
|
https://dimsemenov.com/plugins/magnific-popup/
|
| masonry-layout
|
https://masonry.desandro.com/
|
| moment
|
https://momentjs.com/
|
| morris.js
|
https://morrisjs.github.io/morris.js/
|
| nestable
|
https://dbushell.com/Nestable/
|
| pickadate
|
https://amsul.ca/pickadate.js/
|
| popper.js
|
https://popper.js.org/
|
| prism
|
https://github.com/PrismJS/prism#readme
|
| raphael
|
https://dmitrybaranovskiy.github.io/raphael/
|


- The agent starts in the top left corner.
- Each step gets an negative reward of -1
- If the agent steps on one of the magenta cliff tiles on the top, there is a negative reward of -100 for falling off the cliff and the agent has to start again from the top left corner.
- The goal is to reach the top right corner. When reaching the top right corner, everything starts all over again.
Sometimes it strikes me how dark, twisted and cynical this is, even though it’s just a toy example. Basically it states
- -1 for every step you make means nothing less than living is suffering
- Even if you reach your goal you don’t get any reward, just you’re suffering ends till it starts all over again. You can’t escape.
- Jumping off the cliff won’t help you. You just have to start over again. There’s no escape.
There’s also a much more positive life lesson one could learn from -greedy exploration policies. I’ll definitely have to write about it soon, to balance out this post.


{#template /layout.html} {#def breadcrumbs} Blog / Sign in {/#def} {#def content}
You can login using one of the following services:


REDIST.SYS
REDIST.SYS (\FBB\SYSTEM).
REDIST is a built-in server for resending personal messages as bulletins.
May be used for sending a bulletin in another area than the users own area.
#
# Configuration of the REDIST server
#
# Route for the local BBS (SP LOCBBS)
LOCBBS=LA1B
# Name of the BBS coverage
LOCBBS_DESC=LA1B BBS
#
#Route(s) for local bulletins (SP LOCAL)
LOCAL=LA6CU,LA1B
# Coverage of the local BBS
LOCAL_DESC=Bergen, LA1B and LA6CU BBSs
#
# Route(s) for regional bulletins (SP REGION)
REGION=VEST
# Name of the region
REGION_DESC=Hordaland, Rogaland (Western Norway)
#
# Route(s) for national bulletins (SP NATION)
NATION=NOR
# Name of the country
NATION_DESC=Norway
#
# Default destination
DEFAULT_TO=ALLE
#
# Send a mail to the sysop
MAIL_SYSOP=YES
#
This page was last updated


Assistant Professor
PhD Scholar
PhD Student
M.Tech Student
B.Tech Student
Research Assistant
Undergraduate, BITS Pilani
Research Intern, BITS Pilani
Research Assistant, IIIT Delhi
Researcher, MIDAS@IIITD
Research Assistant, BITS Pilani (Goa Campus)
B.Tech Student, IIIT Delhi
Research Assistant, IIIT-Delhi
B.Tech Student, NSIT
B.Tech Student, DTU
Research Assistant, DTU
Developer, Gramener
Software Developer, Tower Research Capital
Research Fellow, National University of Singapore, Singapore
Assistant Professor, National Institute of Informatics, Japan
Assistant Professor, IIIT-Delhi
Nephropathologist, Arkana Laboratories, USA
Professor, National Institute of Informatics, Japan
Associate Professor, National University of Singapore, Singapore
Associate Professor, IIIT-Delhi
Lecturer, Nottingham Trent University, U.K.
Lecturer, University of Technology Sydney, Australia
Associate Professor, Singapore Management University, Singapore
Research Scientist, Bloomberg LP, USA
Research Scientist, Nanyang Technological University, Singapore


AWS S3 Tool
accessKey
secretAccessKey
Remember
OK
Beijing Region
General Regions
GovCloud (US)
Buckets
Create Bucket
s3://
Objects
Create Folder
Upload Files
File Upload
ACL
Bucket Owner Full Control
Private
Public Read
Public Read & Write
Authenticated Read
Bucket Owner Read
Storage Class
Standard
Reduced Redundancy
Content Type
Figure Out Content Types Automatically
Encryption
Use Server Side Encryption
Start Upload
Properties
Name
Size
ETag
LastModified
StorageClass
URL


1 reference to LookupCommandProcessor
System.Management.Automation (1)
engine\hostifaces\Command.cs (1)
530
commandProcessorBase = executionContext.CommandDiscovery.
LookupCommandProcessor
(CommandText, origin, _useLocalScope);


| CC MSB | CC LSB | MIDI Specification name | Digital Chroma name | Type |
| 0 | 32 | Bank Select | Bank | address |
| 1 | 33 | Modulation | +Lever 1 | poly |
| 3 | 34 | Breath Controller | \-Lever 1 | poly |
| 4 | 36 | Foot Controller | Pedal 1 | poly |
| 6 | 38 | Data Entry | Data | |
| 7 | Channel Volume | Volume | poly | |
| 10 | Pan | Pan | poly | |
| 11 | 43 | Expression Controller | Pedal 2 | poly |
| 12 | 44 | Effect Control 1 | \-Pedal 1 | poly |
| 13 | 45 | Effect Control 2 | \-Pedal 2 | poly |
| 16 | 48 | GP Controller 1 | +Lever 2 | poly |
| 17 | 49 | GP Controller 2 | \-Lever 2 | poly |
| 18 | 50 | GP Controller 3 | Ribbon | poly |
| 64 | Damper Pedal On/Off | Sustain Switch | switch | |
| 65 | Portamento On/Off | Portamento Switch | switch | |
| 64 | Sostenuto On/Off | Latch Switch | switch | |
| 74 | GP Controller 4 | Ribbon | poly | |
| 80 | GP Controller 5 | Link Balance | ||
| 81 | GP Controller 6 | Link Spread | ||
| 82 | GP Controller 7 | Link Detune | ||
| 83 | GP Controller 8 | Reverb Room | switch | |
| 84 | Portamento Controller | Note Select | prefix | |
| 87 | 86 | Pitch | prefix | |
| 88 | High Resolution Velocity | Hi-res Velocity | prefix | |
| 91 | Effects 1 Depth | Reverb Send | ||
| 99 | 98 | NRPN | NRPN | address |
| 101 | 100 | RPN | RPN | address |
| 120 | All Sound Off | All Sounds Off | ||
| 121 | Reset All Controllers | All Controllers Off | ||
| 123 | All Notes Off | All Notes Off |
The address controls supply addressing for subsequent controls, and remain in effect until explicitly changed. They can be sent in any order. The Digital Chroma always sends them MSB first.
The prefix controls supply extra data for subsequent controls, and are consumed by them. They can be sent in any order. The Digital Chroma sends them in ascending order of CC number.
The poly controls can be addressed to specific notes by preceding them with CC84 Note Select.
The switch controls divide the value range into two or four equal zones. For footswitches, one normally uses 0 and 127, and that is what the Digital Chroma sends. For Reverb Room, the Digital Chroma sends 0, 32, 64, or 96.
The levers, pedals, and ribbon only send the LSB if configured as hi-res by global parameters.
CC74 is recognized in performance input as an alternative to CC18, for MPE compatibility.


Owen Hassan murder trial told how his mum found him covered in blood outside her Glasgow pub
David Callaghan, 30, and Craig Corrall, 39, deny killing 30-year-old Owen outside the Old Stag Inn in Glasgow's Pollokshaws.
by Grant McCabeA mum told a murder trial how she tried to save her dying son after he was allegedly attacked outside her pub.
Anne Marie Lynch recalled how she found Owen Hassan “covered in blood” in the street beside the Old Stag Inn bar in Glasgow's Pollokshaws in November 2018.
The 55-year-old initially chased after a man before realising he was with another individual.
Miss Lynch told jurors how her son would “stand up for himself” - but was not aware if he had a “lot of enemies”.
She was giving evidence today at the trial of David Callaghan, 30, and Craig Corrall, 39, at the High Court in Glasgow.
The pair deny murdering 30-year-old Mr Hassan.
The court heard how the dad would often work in his mum's pub, where she was the licensee.
Mr Hassan had gone there on the day of the alleged murder – November 7 last year.
Miss Lynch recalled: “He came in and said: 'I am exhausted. I am just going to go and get a shower'.
“He got the keys for the house. He said he was very tired and was going home.”
She said her son left before she later heard “a bang”.
Miss Lynch ran from behind the bar and spotted Mr Hassan against the pub door.
She added: “I thought he was doing something funny then I could hear thumping and realised something was wrong.”
As the mum ran out, Mr Hassan was on the ground. Miss Lynch then grabbed hold of another man there to “try and stop what was happening”.
This man then broke free and Miss Lynch initially went after him.
She told prosecutor Lynsey MacDonald: “I just thought: “Who are you...what have you done?'.”
Miss Lynch believed the man was armed. She said he then shouted on another person nearby who also appeared to have a weapon.
Miss Lynch said she was told at one stage: “F*** off, missus.”
The mum then recalled: “I ran back to the pub. He was just lying there covered in blood.
“I was trying to get a phone to call an ambulance. I was just trying to help him.”
Paramedics soon arrived to treat Mr Hassan, but he never recovered.
The court heard Miss Lynch later identified two individuals she believed were involved.
Callaghan's QC Brian McConnachie quizzed Miss Lynch on the men she claimed to have seen.
He asked did she shout 'I know who you are' as the mum went after them that night.
Miss Lynch: “I said 'I know who you are', but I did not have a clue who they were. I only said that to frighten them.”
Mr McConnachie also asked the witness about two brothers who lived in the area.
The QC: “Are they people who Owen had issue with?”
Miss Lynch: “Don't think so.”
The advocate suggested Mr Hassan was a person who had a “lot of enemies”.
His mum replied: “Maybe he had enemies...I don't know.”
She also stated during evidence: “Owen stood up for himself, but that does not give them reason for what they had done.”
Mr McConnacie said, after the death, people were putting forward “a number of names” for apparently being involved.
Miss Lynch: “We were all thinking who could have done it, but I was not interested in suggestions.”
The QC added that photos of individuals had been sent to the mum – including of Callaghan.
Mr McConnachie: “Before the identification parade, David Callaghan was given to you as one of the names?”
She replied: “Yes.”
Mr McConnachie: “His photo had been sent to you?”
Miss Lynch: “Yes, but it was like a different guy. The photo was completely different to the person I picked out at the identification parade.”
Prosecutors claim Mr Hassan was chased, seized by the body and the repeatedly struck with knives or machetes.
The trial , before Lord Woolman, continues.


Address Line 1
Address Line 2
City
State
Country
Pin code- 560037
<EMAIL_ADDRESS><EMAIL_ADDRESS>Office:+91-1234567890
Work:+91-1234567891


This documentation relates to Opera's now deprecated .oex Extension API framework for Opera versions <= 12.15 and also provided by our OEX2NEX shim library.
For the latest Opera Extensions API documentation for Opera versions > 12.15 please consult the latest Opera Extensions API documentation online.
The <license>
element mentions the software license. The following attributes are associated with it.
href
: Specifies a URL for accessing the software licenseThe following is an example of licensing an extension under version 2 of the Apache license.
<?xml version="1.0" encoding="utf-8"?>
<widget xmlns="http://www.w3.org/ns/widgets" id="http://example.com/myExtension" version="1.0">
...
<license href="http://www.apache.org/licenses/LICENSE-2.0">
Copyright 2011 Erik the Viking
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
http://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.
</license>
...
</widget>


models¶
Probabilistic Collaborative Representation Learning (PCRL)¶
@author: Aghiles Salah<EMAIL_ADDRESS>-
class
cornac.models.pcrl.recom_pcrl.
PCRL
(k=100, z_dims=[300], max_iter=300, batch_size=300, learning_rate=0.001, aux_info=None, name='pcrl', trainable=True, w_determinist=True, init_params={'G_r': None, 'G_s': None, 'L_r': None, 'L_s': None})[source]¶ Probabilistic Collaborative Representation Learning.
Parameters: - k (int, optional, default: 100) – The dimension of the latent factors.
- z_dims (Numpy 1d array, optional, default: [300]) – The dimensions of the hidden intermdiate layers ‘z’ in the order [dim(z_L), …,dim(z_1)], please refer to Figure 1 in the orginal paper for more details.
- max_iter (int, optional, default: 300) – Maximum number of iterations (number of epochs) for variational PCRL.
- batch_size (int, optional, default: 300) – The batch size for SGD.
- learning_rate (float, optional, default: 0.001) – The learning rate for SGD.
- aux_info (csc sparse matrix, required) – The item auxiliary information matrix, item-context in the PCRL’s paper, in the scipy csc sparse format.
- name (string, optional, default: 'PCRL') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (Theta, Beta and Xi are not None).
- w_determinist (boolean, optional, default: True) – When True, determinist wheights “W” are used for the generator network, otherwise “W” is stochastic as in the original paper.
- init_params (dictionary, optional, default: {'G_s':None, 'G_r':None, 'L_s':None, 'L_r':None}) – List of initial parameters, e.g., init_params = {‘G_s’:G_s, ‘G_r’:G_r, ‘L_s’:L_s, ‘L_r’:L_r}, where G_s and G_r are of type csc_matrix or np.array with the same shape as Theta, see below). They represent respectively the “shape” and “rate” parameters of Gamma distribution over Theta. It is the same for L_s, L_r and Beta.
- Theta (csc_matrix, shape (n_users,k)) – The expected user latent factors.
- Beta (csc_matrix, shape (n_items,k)) – The expected item latent factors.
References
- Salah, Aghiles, and Hady W. Lauw. Probabilistic Collaborative Representation Learning for Personalized Item Recommendation. In UAI 2018.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Collaborative Context Poisson Factorization (C2PF)¶
@author: Aghiles Salah<EMAIL_ADDRESS>-
class
cornac.models.c2pf.recom_c2pf.
C2PF
(k=100, max_iter=100, aux_info=None, variant='c2pf', name=None, trainable=True, init_params={'G_r': None, 'G_s': None, 'L2_r': None, 'L2_s': None, 'L3_r': None, 'L3_s': None, 'L_r': None, 'L_s': None})[source]¶ Collaborative Context Poisson Factorization.
Parameters: - k (int, optional, default: 100) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations for variational C2PF.
- aux_info (array, required, shape (n_context_items,3)) – The item-context matrix, noted C in the original paper, in the triplet sparse format: (row_id, col_id, value).
- variant (string, optional, default: 'c2pf') – C2pf’s variant: c2pf: ‘c2pf’, ‘tc2pf’ (tied-c2pf) or ‘rc2pf’ (reduced-c2pf). Please refer to the original paper for details.
- name (string, optional, default: None) – The name of the recommender model. If None, then “variant” is used as the default name of the model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (Theta, Beta and Xi are not None).
- init_params (dictionary, optional, default: {'G_s':None, 'G_r':None, 'L_s':None, 'L_r':None, 'L2_s':None, 'L2_r':None, 'L3_s':None, 'L3_r':None}) – List of initial parameters, e.g., init_params = {‘G_s’:G_s, ‘G_r’:G_r, ‘L_s’:L_s, ‘L_r’:L_r, ‘L2_s’:L2_s, ‘L2_r’:L2_r, ‘L3_s’:L3_s, ‘L3_r’:L3_r}, where G_s and G_r are of type csc_matrix or np.array with the same shape as Theta, see below). They represent respectively the “shape” and “rate” parameters of Gamma distribution over Theta. It is the same for L_s, L_r and Beta, L2_s, L2_r and Xi, L3_s, L3_r and Kappa.
- Theta (csc_matrix, shape (n_users,k)) – The expected user latent factors.
- Beta (csc_matrix, shape (n_items,k)) – The expected item latent factors.
- Xi (csc_matrix, shape (n_items,k)) – The expected context item latent factors multiplied by context effects Kappa, please refer to the paper below for details.
References
- Salah, Aghiles, and Hady W. Lauw. A Bayesian Latent Variable Model of User Preferences with Item Context. In IJCAI, pp. 2667-2674. 2018.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Indexable Bayesian Personalized Ranking (IBPR)¶
@author: Dung D. Le (Andrew<EMAIL_ADDRESS>-
class
cornac.models.ibpr.recom_ibpr.
IBPR
(k=20, max_iter=100, learning_rate=0.05, lamda=0.001, batch_size=100, name='ibpr', trainable=True, init_params=None)[source]¶ Indexable Bayesian Personalized Ranking.
Parameters: - k (int, optional, default: 20) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- learning_rate (float, optional, default: 0.05) – The learning rate for SGD.
- lamda (float, optional, default: 0.001) – The regularization parameter.
- batch_size (int, optional, default: 100) – The batch size for SGD.
- name (string, optional, default: 'IBRP') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- init_params (dictionary, optional, default: None) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V} please see below the definition of U and V.
- U (csc_matrix, shape (n_users,k)) – The user latent factors, optional initialization via init_params.
- V (csc_matrix, shape (n_items,k)) – The item latent factors, optional initialization via init_params.
References
- Le, D. D., & Lauw, H. W. (2017, November). Indexable Bayesian personalized ranking for efficient top-k recommendation. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management (pp. 1389-1398). ACM.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Online Indexable Bayesian Personalized Ranking (OIBPR)¶
@author: Dung D. Le (Andrew<EMAIL_ADDRESS>-
class
cornac.models.online_ibpr.recom_online_ibpr.
OnlineIBPR
(k=20, max_iter=100, learning_rate=0.05, lamda=0.001, batch_size=100, name='online_ibpr', trainable=True, init_params=None)[source]¶ Online Indexable Bayesian Personalized Ranking.
Parameters: - k (int, optional, default: 20) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- learning_rate (float, optional, default: 0.05) – The learning rate for SGD.
- lamda (float, optional, default: 0.001) – The regularization parameter.
- batch_size (int, optional, default: 100) – The batch size for SGD.
- name (string, optional, default: 'IBRP') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- init_params (dictionary, optional, default: None) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V} please see below the definition of U and V.
- U (csc_matrix, shape (n_users,k)) – The user latent factors, optional initialization via init_params.
- V (csc_matrix, shape (n_items,k)) – The item latent factors, optional initialization via init_params.
References
- Le, D. D., & Lauw, H. W. (2017, November). Indexable Bayesian personalized ranking for efficient top-k recommendation. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management (pp. 1389-1398). ACM.
-
fit
(triplets)[source]¶ Fit the model to observations.
Parameters: triplets (collections of user's ordinal triplets (u, i, j) indicating u prefers i to j) –
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Collaborative Ordinal Embedding (COE)¶
@author: Dung D. Le (Andrew<EMAIL_ADDRESS>-
class
cornac.models.coe.recom_coe.
COE
(k=20, max_iter=100, learning_rate=0.05, lamda=0.001, batch_size=1000, name='coe', trainable=True, init_params=None)[source]¶ Collaborative Ordinal Embedding.
Parameters: - k (int, optional, default: 20) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- learning_rate (float, optional, default: 0.05) – The learning rate for SGD.
- lamda (float, optional, default: 0.001) – The regularization parameter.
- batch_size (int, optional, default: 100) – The batch size for SGD.
- name (string, optional, default: 'IBRP') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- init_params (dictionary, optional, default: None) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V} please see below the definition of U and V.
- U (csc_matrix, shape (n_users,k)) – The user latent factors, optional initialization via init_params.
- V (csc_matrix, shape (n_items,k)) – The item latent factors, optional initialization via init_params.
References
- Le, D. D., & Lauw, H. W. (2016, June). Euclidean co-embedding of ordinal data for multi-type visualization. In Proceedings of the 2016 SIAM International Conference on Data Mining (pp. 396-404). Society for Industrial and Applied Mathematics.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Visual Bayesian Personalized Ranking (VBPR)¶
@author: Guo Jingyao
-
class
cornac.models.vbpr.recom_vbpr.
VBPR
(k=10, d=10, max_iter=100, aux_info=None, learning_rate=0.001, lamda=0.01, batch_size=100, name='vbpr', trainable=True, init_params=None)[source]¶ Visual Bayesian Personalized Ranking.
Parameters: - k (int, optional, default: 5) – The dimension of the latent factors.
- d (int, optional, default: 5) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- shape (n_items, feature dimension), optional, default (aux_info：ndarray,) – Image features of items
- learning_rate (float, optional, default: 0.001) – The learning rate for SGD.
- lamda (float, optional, default: 0.01) – The regularization parameter.
- batch_size (int, optional, default: 100) – The batch size for SGD.
- name (string, optional, default: 'BRP') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- init_params (dictionary, optional, default: None) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V} please see below the definition of U and V.
- U (ndarray, shape (n_users,k)) – The user latent factors, optional initialization via init_params.
- V (ndarray, shape (n_items,k)) – The item latent factors, optional initialization via init_params.
- E (ndarray, shape (d, feature dimension)) – The matrix embedding deep CNN feature, optional initialization via init_params.
- Ue (ndarray, shape (n_users, d)) – The visual factors of users, optional initialization via init_params.
References
- HE, Ruining et MCAULEY, Julian. VBPR: Visual Bayesian Personalized Ranking from Implicit Feedback. In : AAAI. 2016. p. 144-150.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Spherical k-means (Skmeans)¶
@author: Aghiles Salah<EMAIL_ADDRESS>-
class
cornac.models.skm.recom_skmeans.
SKMeans
(k=5, max_iter=100, name='Skmeans', trainable=True, tol=1e-06, verbose=True, init_par=None)[source]¶ Spherical k-means based recommender.
Parameters: - k (int, optional, default: 5) – The number of clusters.
- max_iter (int, optional, default: 100) – Maximum number of iterations.
- name (string, optional, default: 'Skmeans') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model is already trained.
- tol (float, optional, default: 1e-6) – Relative tolerance with regards to skmeans’ criterion to declare convergence.
- verbose (boolean, optional, default: True) – When True, the skmeans criterion (likelihood) is displayed after each iteration.
- init_par (numpy 1d array, optional, default: None) – The initial object parition, 1d array contaning the cluster label (int type starting from 0) of each object (user). If par = None, then skmeans is initialized randomly.
- centroids (csc_matrix, shape (k,n_users)) – The maxtrix of cluster centroids.
References
- Salah, Aghiles, Nicoleta Rogovschi, and Mohamed Nadif. “A dynamic collaborative filtering system via a weighted clustering approach.” Neurocomputing 175 (2016): 206-215.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Hierarchical Poisson Factorization (HPF)¶
@author: Aghiles Salah<EMAIL_ADDRESS>-
class
cornac.models.hpf.recom_hpf.
HPF
(k=5, max_iter=100, name='HPF', trainable=True, init_params={'G_r': None, 'G_s': None, 'L_r': None, 'L_s': None})[source]¶ Hierarchical Poisson Factorization.
Parameters: - k (int, optional, default: 5) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations.
- name (string, optional, default: 'HPF') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model is already pre-trained (Theta and Beta are not None).
- init_params (dictionary, optional, default: {'G_s':None, 'G_r':None, 'L_s':None, 'L_r':None}) – List of initial parameters, e.g., init_params = {‘G_s’:G_s, ‘G_r’:G_r, ‘L_s’:L_s, ‘L_r’:L_r}, where G_s and G_r are of type csc_matrix or np.array with the same shape as Theta, see below). They represent respectively the “shape” and “rate” parameters of Gamma distribution over Theta. Similarly, L_s, L_r are the shape and rate parameters of the Gamma over Beta.
- Theta (csc_matrix, shape (n_users,k)) – The expected user latent factors.
- Beta (csc_matrix, shape (n_items,k)) – The expected item latent factors.
References
- Gopalan, Prem, Jake M. Hofman, and David M. Blei. Scalable Recommendation with Hierarchical Poisson Factorization. In UAI, pp. 326-335. 2015.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Bayesian Personalized Ranking (BPR)¶
@author: Guo Jingyao
-
class
cornac.models.bpr.recom_bpr.
BPR
(k=5, max_iter=100, learning_rate=0.001, lamda=0.001, batch_size=100, name='bpr', trainable=True, init_params={'U': None, 'V': None})[source]¶ Bayesian Personalized Ranking.
Parameters: - k (int, optional, default: 5) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- learning_rate (float, optional, default: 0.001) – The learning rate for SGD.
- lamda (float, optional, default: 0.001) – The regularization parameter.
- batch_size (int, optional, default: 100) – The batch size for SGD.
- name (string, optional, default: 'BRP') – The name of the recommender model.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- init_params (dictionary, optional, default: {'U':None,'V':None}) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V}. U: a csc_matrix of shape (n_users,k), containing the user latent factors. V: a csc_matrix of shape (n_items,k), containing the item latent factors.
References
- Rendle, Steffen, Christoph Freudenthaler, Zeno Gantner, and Lars Schmidt-Thieme. BPR: Bayesian personalized ranking from implicit feedback. In UAI, pp. 452-461. 2009.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array
Probabilitic Matrix Factorization (PMF)¶
@author: Aghiles Salah
-
class
cornac.models.pmf.recom_pmf.
PMF
(k=5, max_iter=100, learning_rate=0.001, gamma=0.9, lamda=0.001, name='pmf', variant='non_linear', trainable=True, rating_range=[None, None], init_params={'U': None, 'V': None})[source]¶ Probabilistic Matrix Factorization.
Parameters: - k (int, optional, default: 5) – The dimension of the latent factors.
- max_iter (int, optional, default: 100) – Maximum number of iterations or the number of epochs for SGD.
- learning_rate (float, optional, default: 0.001) – The learning rate for SGD_RMSProp.
- gamma (float, optional, default: 0.9) – The weight for previous/current gradient in RMSProp.
- lamda (float, optional, default: 0.001) – The regularization parameter.
- name (string, optional, default: 'PMF') – The name of the recommender model.
- variant ({"linear","non_linear"}, optional, default: 'non_linear') – Pmf variant. If ‘non_linear’, the Gaussian mean is the output of a Sigmoid function. If ‘linear’ the Gaussian mean is the output of the identity function.
- trainable (boolean, optional, default: True) – When False, the model is not trained and Cornac assumes that the model already pre-trained (U and V are not None).
- rating_range (1d array, optional, default: [None,None]) – The minimum and maximum rating values, e.g., [1,5].
- init_params (dictionary, optional, default: {'U':None,'V':None}) – List of initial parameters, e.g., init_params = {‘U’:U, ‘V’:V}. U: a csc_matrix of shape (n_users,k), containing the user latent factors. V: a csc_matrix of shape (n_items,k), containing the item latent factors.
References
- Mnih, Andriy, and Ruslan R. Salakhutdinov. Probabilistic matrix factorization. In NIPS, pp. 1257-1264. 2008.
-
fit
(X)[source]¶ Fit the model to observations.
Parameters: X (scipy sparse matrix, required) – the user-item preference matrix (traning data), in a scipy sparse format (e.g., csc_matrix).
-
rank
(user_index, known_items=None)[source]¶ Rank all test items for a given user.
Parameters: - user_index (int, required) – The index of the user for whom to perform item raking.
- known_items (1d array, optional, default: None) – A list of item indices already known by the user
Returns: Array of item indices sorted (in decreasing order) relative to some user preference scores.
Return type: Numpy 1d array
-
score
(user_index, item_indexes=None)[source]¶ Predict the scores/ratings of a user for a list of items.
Parameters: - user_index (int, required) – The index of the user for whom to perform score predictions.
- item_indexes (1d array, optional, default: None) – A list of item indexes for which to predict the rating score. When “None”, score prediction is performed for all test items of the given user.
Returns: Array containing the predicted values for the items of interest
Return type: Numpy 1d array


Which timebox and habits techniques did you try?
I always try my best to be mindful and the Pomodoro technique. But I tend to spend half an hour focussing and then having a break and repeat that. Helps me focus so much.
What did you find interesting?
How many different techniques there are and how some work for some people but not for others
What worked for you?
Pomodoro technique.
Which will you experiment further with?
Maybe I will try some forms of meditation, to help me unwind when I am stressed.


{% extends "base.html" %} {% block title %}Welcome{% endblock %} {% include "navbar.html" %} {% block content %}
Your API key is 'an-auth-token'
In order to gather data from the API, you will need to POST your API token in your header call. The most basic call would be:
curl -X POST -H 'X-Authentication-Token: 'an-auth-token' localhost:8080/hits/
Returns:
{"count": "1","token": "an-auth-token-hit"}
This will return the number of times the API has been accessed and an authorization token.
To get monthly counts for a given search term, you need to provide the query term and the month in the following format:
curl -X POST -H 'X-Authentication-Token: 9s2xX3RgH7jcHf, Search: Obama, Month: 08' localhost:8080/hits/
This will return the number of page hits that a wikipedia entry related to the search term Obama saw in the entire month of October:
{ "barack_obama": "325,671", "barack_obama_sr": "6,942" }
If you wish to refresh your API key, revoking the old one, click below:


As we continue to build and develop products for Singapore, we want to ensure that no one is left behind. Whether it means including video captions to help people with hearing difficulties, ensuring legibility of content through high-contrast text, or even presenting information in an understandable manner. Designing for accessibility means your digital products can be used and enjoyed by the majority.


Check if recent Facebook phone number leak contains your data
All info you provide on this site is hashed in your browser before sending out. I will never know what
you've put there.
Feel free to check the source code at: https://github.com/domints/FacebookPhoneLeak
Check by phone number
In progress
Enter phone number (with country code!) to check if it exists in the
database


Filters a spectrum using an RC filter.
yFilt = rcfilt(y,SampTime,TimeConst) yFilt = rcfilt(y,SampTime,TimeConst,'up') yFilt = rcfilt(y,SampTime,TimeConst,'down')
rcfilt
pipes the input signal y
, usually an EPR spectrum,
through a low-pass RC filter hard-wired into all cw EPR spectrometers.
SampTime
is the time used to obtain one point in the signal
(usually called conversion time or sampling time),
TimeConst
gives the time constant of the RC filter.
These two parameters must have the same time units (e.g. milliseconds).
rcfilt
returns the filtered signal, which actually depends only
on the ratio of SampTime
and TimeConst
.
Be careful to assure that the first few points of the spectrum (usually baseline)
are zero, otherwise an unwanted fade-in effect will appear.
The sweep direction of the field can be specified by an additional parameter,
either 'up'
or 'down'
. If this is not specified,
'up'
is assumed by default.
If y
is a matrix, rcfilt
operates on each column
in turn.
If TimeConst
is zero, no RC filtering is performed.
When recording CW EPR spectra, an RC filter is usually used to remove
high frequency noise, thereby increasing the signal-to-noise ratio.
Let's look at the effect of the RC filter on a noisy EPR spectrum.
First we construct a dummy EPR spectrum spec
with noise.
field = linspace(340,350,1e3); noise = 0.5*randn(size(field)); width = 1; spec = gaussian(field,345,width,1) + noise;
Next we apply the RC filter and plot the result.
spec_smooth = rcfilt(spec,1,20); plot(field,spec,'r',field,spec_smooth,'k')
Here we have used a time constant of 20 milliseconds for a conversion time of 1 millisecond. The noise level decreases significantly, and the signal centre shifts slightly to the right. If the field sweep is downwards, the centre shifts slightly to the left:
spec_smooth_d = rcfilt(spec,1,20,'down'); plot(field,spec,'r',field,spec_smooth_d,'k')
datasmooth, gaussian, lorentzian, lshape, fieldmod, voigtian


A spectacular reimagining of one of the most visionary games ever, FINAL FANTASY VII REMAKE rebuilds and expands the legendary RPG for today.
Join Cloud Strife, a former member of Shinra’s elite SOLDIER unit now turned mercenary, as he lends his aid to the anti-Shinra organization, Avalanche, unaware of the epic journey that awaits him.
The FFVII Remake combines incredible visuals, stunning world-design, a glorious musical score, seamless strategic action-based combat and a captivating cast of characters.
Assess your enemies' strengths and weaknesses, and employ powerful magic and special abilities to fight effectively through Midgar in a mix of traditional command-based combat and real-time action.
An ex-SOLDIER: first class, Cloud came to Midgar to start a new chapter of his life as a mercenary.
A flower seller who lives in the Sector 5 slums, Shinra has kept a close eye on Aerith ever since she was a child.
Although a loyal member of Avalanche, Tifa is not convinced that bombing mako reactors is the solution.
The leader of an independent Avalanche cell in Midgar, Barret was disavowed by the old guard for his extreme methods.


This documentation teaches you how to properly use and configure {{ names.name( 'scala-android' ) }}. It neither teaches you {{ names.name( 'scala' ) }} nor {{ names.name( 'android' ) }} development.
{% call alert( warning ) %}When you have no experience with either {{ names.name( 'scala' ) }} or {{ names.name( 'android' ) }} development yet, please consider that both technologies come with quite a steep learning curve. It is highly recommended to first get a basic understanding for both technologies separately.
{% endcall %}


| Classes Summary | |
|---|---|
| Parsec | Parsec data class. |
| Yard | Yard data class. |
| Millimetre | Millimetre data class. |
| Micrometre | Micrometre data class. |
| Picometre | Picometre data class. |
| Decimetre | Decimetre data class. |
| Kilometre | Kilometre data class. |
| Hand | Hand data class. |
| Centimetre | Centimetre data class. |
| Mile | Mile data class. |
| LengthUnit | Length unit base data class. Any new length units should extend this class and implement their name, symbol and units; overriding the $unitOf and $base properties only if necessary. |
| Inch | Inch data class. |
| Foot | Foot data class. |
| Metre | Metre data class. All units of Length are based off of Metre. |
| AstronomicalUnit | AstronomicalUnit data class. |
| Lightyear | Lightyear data class. |
| Nanometre | Nanometre data class. |