This is an Open Source Hardware project. Schematics and board design files are available in the /hardware directory of the repo.
The badge uses the same core module as the Puck.js and can run most of the same software.
Hardware Features include:
You write to or read from a pin with:
digitalWrite(pin, value);
digitalRead(pin);
where pin is one of D0, D1, D2, D3, D4, D5, D6, D7, D8 (D0 at top) and value is 0 or 1.
The firmware has some extra API calls and variables for some of the badge features. You can use them as follows:
You can use
digitalWrite(button, value);
digitalRead(button);
where value is 1 or 0 and button is one of BTNA, BTNB, BTNU, BTND, BTNL, BTNR
If you add LEDs to the corner holes, you can turn them on/off with
digitalWrite(led);
where led is one of LED1, LED2, LED3, LED4, LED5, LED6.
In many Espruino examples on the main site, you’ll find setup code for different types of screens. That has already been taken care of for you on the badge and you can just access the graphics functions directly. e.g.
g.clear();
g.drawString("Hello World",0,0);
g.flip();
You can read the capacitance (and hence touch) from the 6 corners using
Badge.capSense(corner);
where corner is one of CORNER1, CORNER2, CORNER3, CORNER4, CORNER5, CORNER6.
You can get an estimate of the battery level by calling
Badge.getBatteryPercentage();
It returns an approximate battery percentage remaining based on a normal CR2032 battery (2.8 - 2.2v).
You can set the screen contrast with
Badge.setContrast(c)
where c is a float from 0 to 1
You can set the URL that the NFC antenna broadcasts to NFC-capable phones by calling
NRF.nfcURL("url")
where URL is something like https://www.nearform.com
NOTE: If your phone is having difficulty picking up the NFC URL, it is likely that the tuning capacitors on your badge need to be changed to different values. Head on over to the Hacking Lounge to get them replaced or be shown how to do it yourself.
If you need to flash new firmware to the badge, you must first put it in DFU mode by holding BTNA as you insert the battery and quickly letting go of BTNA. Download the Distribution Packet Zip file containing the new firmware to your phobe and use nRF Toolbox on either Android or iOS to send it to the badge.


Hello there, awesome person!
To music:
YoutubeMusic
To communication:
WhatsappWeb
To programm:
GitHub


---
layout: theorems
---
Number of Elements in a Linearly Independent Set
Let $V$ be a vector space spanned by a finite set of vectors $\{u_1, \dots, u_m\}$. Then any linearly independent set in $V$ has at most $m$ elements.
Concepts
Coming soon
Hypothesis
Coming soon
Results
Coming soon
Proof
Coming soon


| Class | Description |
|---|---|
| AbstractCopySQLData |
Class for creating mappings between CloverETL's DataRecords and JDBC's
ResultSets.
|
| AbstractCopySQLData.CopyArray | |
| AbstractCopySQLData.CopyBlob | |
| AbstractCopySQLData.CopyBoolean |
Copy object for boolean/bit type fields.
|
| AbstractCopySQLData.CopyByte | |
| AbstractCopySQLData.CopyDate |
Description of the Class
|
| AbstractCopySQLData.CopyDecimal |
Description of the Class
|
| AbstractCopySQLData.CopyDouble |
Only used in Exasol so far.
|
| AbstractCopySQLData.CopyInteger |
Description of the Class
|
| AbstractCopySQLData.CopyLong | |
| AbstractCopySQLData.CopyNumeric |
Description of the Class
|
| AbstractCopySQLData.CopyOracleXml |
This class is used SOLELY for conversion of Oracle's XML columns into string data fields.
|
| AbstractCopySQLData.CopyString |
Description of the Class
|
| AbstractCopySQLData.CopyStringToString |
CL-2748
This class should be used instead of
AbstractCopySQLData.CopyString
when the target field is a StringDataField . |
| AbstractCopySQLData.CopyTime |
Description of the Class
|
| AbstractCopySQLData.CopyTimestamp |
Description of the Class
|
| AbstractDBConnection |
Ad hoc base class with metadata generation logic.
|
| AnalyzeDB |
Class easing creation of Clover metadata describing data originating in Database.
|
| AutoKeyGenerator |
Class for filling output record by keys got from database.
|
| DBConnectionImpl |
CloverETL class for connecting to databases.
|
| SQLCloverCallableStatement | |
| SQLCloverStatement |
This class represents prepared statement with CopySQLData[] object prepared to work with concrete record.
|
| SQLDataParser |
Gets records from database.
|
| SQLIncremental |
This is class for incremental reading.
|
| SQLScriptParser |
Splits SQL script into series of SQL statements.
|
| SQLUtil |
Various utilities for working with Databases
|
| Enum | Description |
|---|---|
| ConnectionAction | |
| IncrementalKeyType |
Types of database incremental key
|
Copyright © 2002-2015 Javlin a.s.


Mr. Sosa:
Add payment:
Concept
Description
Amount
Status
Paid
Unpaid
Date
Add
Preview:
Concept
Description
Amount
Status
Date
Total:
Submit all and finish


Changes the format of the active chart to a radar chart.
Syntax
GALLERY.RADAR(type_num, delete_overlay)
GALLERY.RADAR?(type_num, delete_overlay)
Type_num is the number of the format you want to apply to the radar chart.
Delete_overlay is a logical value specifying whether to delete an overlay chart.
If delete_overlay is TRUE, Microsoft Excel deletes all overlays, if present, and applies the new format to the main chart.
If delete_overlay is FALSE or omitted, Microsoft Excel applies the new format to either the main chart or the overlay, depending on the location of the selected series.
Return to index


Vibrational density of states (VDOS) from ab initio MD. (A) VDOS of pure water showing the vibrational (HB stretch) and librational bands. (B) Comparison of the VDOS of pure water and of the water molecules in the first hydration shell of Mg 2+ and Ca 2+. The first shells were defined by the position of the first minimum of the Mg−O (3.0 Å) and Ca−O (3.2 Å) RDFs.


And the beast shall come forth surrounded by a roiling cloud of vengeance. The house of the unbelievers shall be razed and they shall be scorched to the earth. Their tags shall blink until the end of days. from The Book of Mozilla, 12:10 »
»


You create the journey, we supply the parts.
Please contact us for all inquiries and purchase options.


Here you will find some users of TestLink Plug-in and other additional info that help to understand the benefits of using the plug-in. Send an e-mail to Bruno P. Kinoshita to have your case listed here.
TupiLabs
TupiLabs is an Open Source and innovation company based in Sao Paulo, Brazil. The plug-in is used to automate a series of internal projects using different programming languages and (mostly) TAP.
Elektrobit Automotive GmbH
Elektrobit Automotive is the leading automotive software supplier for the world's biggest car manufacturers and Tier-1s, covering ECU applications as well as infotainment solutions (HMI, navigation, speech) and driver assistance applications. Testing is extremely important in our projects. We are using TestLink for requirements engineering, test specification and planning of test execution in an increasing number of projects. Automated tests are specified and planned in TestLink and executed via the TestLink-Jenkins plugin.
We appreciate the work of the developers of TestLink and the Jenkins plugin.
Sysmap Solutions
Sysmap Solutions is a Brazilian company with headquarters in Sao Paulo and branch offices in the cities of Belo Horizonte and Uberlandia. With extensive experience in complex and high-performance IT projects, our goal is to align ourselves with our clients’ business interests and to establish long-lasting partnerships to optimize results.
We are using the plug-in to integrate TestLink 1.9.1 and Jenkins 1.400. Our test project is developed for a mobile carrier customer and consists of TestNG and Selenium functional web tests. However we are planning to add new tests to test the Service Bus too.
Fifthplay NV
Fifthplay develops and produces innovative technologies for energy management in buildings and health monitoring of patients. We are also actively working on the further integration of technology into our buildings and cities.
We combine Jenkins with testlink to run Jmeter tests for web services.
Fifthplay is part of the Niko Group.


The reverse periodization model for triathletes is based on starting training blocks building a foundation that involves, technique, strength and speed rather than laying an aerobic endurance base, as with traditional periodization models.
Obviously it made no sense adding volume in training when the basic foundation of skills were not yet developed!
How much can we gain by adding extra slow miles to our training in the early season? 2 or 3% in performance? Now how much can we gain by developing proper motor skills and technique, strength and speed? A lot more than that I can assure you.
Further, doing too much volume or long intense sessions all year round is one sure way to destroy the body’s immune function, endocrine balance and biomechanical health for very long durations due to highly catabolic approaches to training. Little explosive speed or strength built into their training, and a general lack of emphasis on basic motor skill development. As a result, the strong focus on aerobic “gains” (catabolic) without the corresponding balance of more anabolic training sessions leads to increasing breakdown, generally evident in increasingly poor performances, greater fatigue, more injuries.
Reverse Periodization applies training stimulation of carefully selected fitness components for a set block of time, an approach sometimes referred to as “Block Periodization.” (Dr. Vladimir Issurin)
For most athletes, the long endurance base training is done in the winter and spring months, so by March or April, athletes are at the highest level of endurance possible. But unfortunately for most athletes, they end up racing in June and July and by this time; the level of endurance is lower than when they started in April. If we look at a triathlon event itself, where endurance is 85% of the race, we want to arrive at the race at the highest endurance level possible. The same is true for the racing season—we want our highest levels of endurance at race time.
By doing your endurance training close to the race instead, the athlete will race with a higher aerobic capacity. As we know, contrary to speed, motor skills and strength, endurance is the easiest to gain but also the easiest to lose. And for athletes living in North America and Europe, trying to log long miles on the bike and run can be challenging during winter and most of spring season.
As an athlete, particularly if you have been training for a while, it is so much easier to gain endurance than speed. So, when athletes spend 3 or 4 months doing only endurance, they end up staying away from speed workouts far too long. When they get back to speed work, they lost most of their last season speed, mobility, elasticity and strength. It makes the process of getting fast again longer and more difficult. It is important to do speed work all year long so that you never lose speed to any great extent. We start doing speed work at the beginning of the training season. The basic principle is that we are trying to get to as high a speed as possible before we put on the volume. This is what we call inverse periodization.
As the training process and athletes start a training cycle specifically for long distance races (½ IM and up), intensity is reduced and volume increased. If the athletes didn’t bring their speed base to a very high level, they’re never going to get faster, because as we know, they’ll lose some speed during the high volume phase. The question I’m sure many of you have is, what about the endurance? If you do focus on speed early in the preparation cycle, will endurance suffer? The answer, and it is important to remember, for an experienced athlete, you don’t need more than 6-8 weeks to get your endurance back to a higher level. Another thing to remember is that you don’t give up endurance altogether when you do your speed training. Endurance happens as a by-product of all the other training.


Catastrophe Rescue Map
I am needing help.
I may help.
Here is food.
Here is medical supplies.
Here is equipment.
Here is a assemply point.
Ein Projekt von Gregor,Falk,Randolph und Benedikt!
| Spenden an Roteskrez |
| Spenden an Ärtzte ohne Grenzen |
| Spenden an unicef |


Loading...
Enqueue
Status
API key
Enqueue
Loading queue items...
TODO
There is no API key for this user. You can request one at
service@stack-buster.com


Access has been granted successfully.
Thanks for installing scroblr! Your account information is now being retrieved. Close this window and begin scrobbling!
scroblr supports the following web players:


# Markdown Demo ## What is Lorem Ipsum? Lorem Ipsum is simply dummy text of the **printing** and __typesetting__ industry. Lorem Ipsum has been the *industry's standard* dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum. ### Why do we use it? It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to... #### This is a unordered list * item 1 * item 2


About me
News
Fractals
CvMob
Abep-UK
Lucas França
Doctoral Researcher
University College London
About Me
Fractals
CvMob
Abep-UK


:tendon
:one dressed for use as a cord or thread
:nerve
:solid resilient strength :power astonishing intellectual sinew and clarity Reynolds Price
:the chief supporting force :mainstay usually used in plural providing the sinews of better living Samuel Pollock


DjangoCon US will be providing two platforms for live chat during the conference
{% comment %}delete the bit about coming back when it's showtime{% endcomment %} We'll use Discord and Spatial Chat for live chat. Come back around October 20th to get your invitations!
Discord
You can join our Discord server at LINK GOES HERE. We'll use it for live Q&A and general discussions
Spatial Chat
You can join our Spatial Chat instance at LINK GOES HERE. We'll use it as a virtual hallway track as well as social discussions during lunch and after each day's talks. Sponsors will also be there during lunch and breaks for you to visit with them.


Engineering Resident @ Google
I'm a recent college graduate who will be working in tech. I love to problem-solve and learn new things.
Swarthmore Senior Thesis Live RSSI Mapping System is a tool to monitor and display signal strength in an intuitive format with Tim Nguyen
Engineering Pranks I was the head of the Swarthmore Society of Engineers for my junior and senior years at Swarthmore. Both years, we created funny and topical pranks by recruiting dozens of engineers.
Website Design I built an e-commerce website for JuniorsRead, a start-up that seek to improve colored children's literacy.
Chess Enthusiast I love chess. In high school, I used to play bughouse with some friends. I enjoy solving tactics and playing games with new people.
Quantitative Algorithm Builder Learned how to quant trade from scratch.
Capital One 2018 Summer Data Science Intern
Real Atom 2017 Summer Business Development Intern
Think Tanks 2016 Summer Technology and Development Intern
Passport to Wallstreet Contributor Wrote several articles that were translated for this magazine. Contact me for English versions.


Module tVar_sub.misc
misc script contains function not intend to be used by users
Functions
| tVar:setName (_nameTex) | sets the name of tVar object |
| tVar:setFormat (_numformat) | sets the numberformat of tVar object |
| tVar:clean (_nameTex) | removes all calculation steps from tVar object.align |
| tVar:setUnit (_unit) | sets unit of tVar object |
| tVar:getUnit () | gets unit of tVar object |
| tVar:copy () | copy tVar to get rid of references |
| tVar:bracR () | sourrounds the tVar objects eqTex and eqNum with round brackets |
| tVar:bracB () | sourrounds the tVar objects eqTex and eqNum with round brackets |
| tVar:bracC () | sourrounds the tVar objects eqTex and eqNum with round brackets |
| tVar:brac (left, right) | sourrounds the tVar objects eqTex and eqNum with any bracket |
| tVar:CRLF (symb) | adds linebreak in eqNum after tVar |
| tVar:CRLFb (symb) | adds linebreak in eqNum before tVar |
| tVar:CRLF_EQ (symb) | adds linebreak in eqTex after tVar |
| tVar:CRLFb_EQ (symb) | adds linebreak in eqTex before tVar |
| tVar.Check (_a) | Checks if overloaded param is tVar or not if not for calculation purposes the overloaded param is converted to tVar an returned eq number 17 is return as tVar:New(17,"17.0") |
| tVar.valuesFromtVar (tVarTable) | function returns table of vlaues from tVar objects |
| tVar.link (luaFunction, texBefore, texAfter, returntype) | used for converting lua functions to tVar function with mathematical representation |
| tVar:roundValToPrec () | rounds result to internal precision |
| tVar.roundNumToPrec (val) | rounds result to internal precision |
| tVar.q (_) | quick input mode converts a string to a variable Deprecated |
| tVar.formatVarName (_string) | formats a value with underscores to a latex subscript first _ ist subscript first __ is exponent rest gets , |
Functions
- tVar:setName (_nameTex)
-
sets the name of tVar object
Parameters:
- _nameTex (string) LaTeX representation
Returns:
-
(tVar) self
- tVar:setFormat (_numformat)
-
sets the numberformat of tVar object
Parameters:
- _numformat (string) Lua numberformat
Returns:
-
(tVar) self
- tVar:clean (_nameTex)
-
removes all calculation steps from tVar object.align
Parameters:
- _nameTex (string, optional) LaTeX representation
Returns:
-
self
- tVar:setUnit (_unit)
-
sets unit of tVar object
Parameters:
- _unit (string) Unit
Returns:
-
self
- tVar:getUnit ()
-
gets unit of tVar object
Returns:
-
string
- tVar:copy ()
-
copy tVar to get rid of references
Returns:
-
(tVar) copied
- tVar:bracR ()
-
sourrounds the tVar objects eqTex and eqNum with round brackets
Returns:
-
(tVar) self
- tVar:bracB ()
-
sourrounds the tVar objects eqTex and eqNum with round brackets
Returns:
-
(tVar) self
- tVar:bracC ()
-
sourrounds the tVar objects eqTex and eqNum with round brackets
Returns:
-
(tVar) self
- tVar:brac (left, right)
-
sourrounds the tVar objects eqTex and eqNum with any bracket
Parameters:
- left
- right
Returns:
-
(tVar) self
- tVar:CRLF (symb)
-
adds linebreak in eqNum after tVar
Parameters:
- symb (string,optional) Symbol is added before and after linebreak return (tVar) with brackets
- tVar:CRLFb (symb)
-
adds linebreak in eqNum before tVar
Parameters:
- symb (string,optional) Symbol is added before and after linebreak
Returns:
-
(tVar) with brackets
- tVar:CRLF_EQ (symb)
-
adds linebreak in eqTex after tVar
Parameters:
- symb (string,optional) Symbol is added before and after linebreak return (tVar) with brackets
- tVar:CRLFb_EQ (symb)
-
adds linebreak in eqTex before tVar
Parameters:
- symb (string,optional) Symbol is added before and after linebreak
Returns:
-
(tVar) with brackets
- tVar.Check (_a)
-
Checks if overloaded param is tVar or not
if not for calculation purposes the overloaded param
is converted to tVar an returned
eq number 17 is return as tVar:New(17,"17.0")
Parameters:
- _a (tVar,number) param to be cecked
Returns:
-
(tVar) _a as tVar
- tVar.valuesFromtVar (tVarTable)
-
function returns table of vlaues from tVar objects
Parameters:
- tVarTable (tVar table)
Returns:
-
table of tVar.val
- tVar.link (luaFunction, texBefore, texAfter, returntype)
-
used for converting lua functions to tVar function with mathematical representation
Parameters:
- luaFunction function to be converted to tVar function
- texBefore (string) text is added befor the list of tVar function names
- texAfter (string) same as texBefor but after the list
- returntype (tVar,tMat oder tVec) tVar is default
Returns:
-
(tVar) result of lua function with tVar paramters
- tVar:roundValToPrec ()
-
rounds result to internal precision
Returns:
-
(number) val of tVar roundet to calcPrecision
- tVar.roundNumToPrec (val)
-
rounds result to internal precision
Parameters:
- val (number)
Returns:
-
(number) val of tVar roundet to calcPrecision
- tVar.q (_)
-
quick input mode converts a string to a variable
Deprecated
Parameters:
- _
- tVar.formatVarName (_string)
-
formats a value with underscores to a latex subscript
first _ ist subscript first __ is exponent rest gets ,
Parameters:
- _string with underscore format
Returns:
-
(string) latex subscript


Engineer seeking a challenging position in a collaborative environment where my analytical background and interpersonal skills will add organizational value through data-driven analysis and process optimization
Carbon Neutral Fuels, June 2016
Din Tai Fung, Jan 2014 - Present | Bartender
Mary’s Place, Aug 2017 - Present | Volunteer
Tesoro Corporation, Apr 2015 - Sept 2015 | Engineering Intern
Code Fellows, Expected July 2019
Certificate - Advance Software Development in Full-Stack JavaScript
University of Washington, Seattle, WA, June 2016
Bachelor of Science in Chemical Engineering


I am a computer geek interested in the web and interactive Javascript apps and AppSec. Here you will find my bio, free time projects and some other stuff. What you won't find are some nice and creative design skills. I also love spending time scrapping the web, poking around in linux based operating systems and automating certain tasks by making time-saving scripts in python and bash.
Responsible for:
Projects worked on:
Projects worked on:
Advanced course
Advanced course
Bachelor thesis: "Message analysis using text or stylometric analysis"
Master thesis: "Detection of attacks via e-mail with text processing methods"


Source code for CustomArduinoDevice.blacs_workers
"""The file that binds really to the Arno Tower.
This is where BLACS really connects to the hardware. Everything elso is just sending it here.
"""
import serial
import time
import labscript_utils.h5_lock
import h5py
from blacs.tab_base_classes import Worker
[docs]class CustomArduinoDeviceWorker(Worker):
"""The class behind the Worker. It inherits from Worker.
Attributes:
connection: Not sure here.
shot_file: Not sure here.
"""
[docs] def init(self):
"""Initialize the Worker.
Initializes ther serial port and resets everything properly.
"""
# Make a serial connection to the device. The com port and buad rate which
# were passed to us from the BLACS tab are now available as instance attributes
self.connection = serial.Serial(
self.com_port, baudrate=self.baud_rate, timeout=0.1
)
ser = self.connection
# every time the device is restarted in BLACS,we reset the arduino after opening the serial port; this is a peculiar nature of our setup.
# Note that this reset when called here, doesn't run in every shot.
self.reset_connection(ser)
# Could send and receive data here to confirm the device is working and do
# any initial setup that is not related to any particular shot.
# Each shot, we will remember the shot file for the duration of that shot
self.shot_file = None
[docs] def reset_connection(self, ser):
""" Reset connection.
This function, when called resets the arduino. Please be aware that the serial port should be open before you call this function.
It resets Arduino DUE, and clears everything in its input and reads fresh from the arduino. The arduino when ready for the string
to be written for the ramps displays 'Arduino ready', which is displayed in the device in BLACS. If you don't see this, check your code.
Args:
ser: The serial connection to the Arduino.
Returns:
Nothing really.
"""
print(
self.connection.is_open
) # check whether the port is open. Displays True in the BLACS device tab
ser.setRTS(True)
ser.setDTR(True)
time.sleep(0.1)
ser.setRTS(False)
ser.setDTR(False)
ser.reset_input_buffer()
line = ser.readline()
ard_str = line[0:-2]
print(ard_str)
[docs] def check_remote_values(self):
"""Queries device for current output settings.
Not sure about the details here.
Returns:
results as a dictionary to update the BLACS tab.
"""
results = {}
return results
# We don't use this method but it needs to be defined:
[docs] def program_manual(self, values):
""" Required - But a dummy we do not use.
Not sure how to do this one properly.
Args:
values: Not sure here.
Returns:
Empty dict.
"""
return {}
[docs] def transition_to_buffered(self, device_name, h5_file, initial_values, fresh):
""" Required - Read commands from the shot file and send them to the device.
Not sure about the right description here.
Args:
device_name: Not sure here.
h5_file: Not sure here.
initial_values: Not sure here.
fresh: Not sure here.
Returns:
Empty dict.
"""
# this is when the hardware communication begins. It's important to reset the arduino here.
self.reset_connection(self.connection)
self.shot_file = h5_file
with h5py.File(self.shot_file, "r") as f:
group = f[f"devices/{self.device_name}"]
if "START_COMMANDS" in group:
start_commands = group["START_COMMANDS"][:]
else:
start_commands = None
# It is polite to close the shot file (by exiting the 'with' block) before
# communicating with the hardware, because other processes cannot open the file
# whilst we still have it open
for command in start_commands:
print(f"sending command: {repr(command)}")
self.connection.write(command)
# self.connection.flush()
# this command is written in Experiment.py, which is fetched here and actually written onto the arduino
# you will see this in the BLACS device tab. It's nothing but the string that we should send to the arduino
# inorder to control the DDS
# This is expected by BLACS, we should return the final values that numerical
# channels have from th shot - for us we have no channels so this is an empty
# dictionary
return {}
[docs] def transition_to_manual(self):
""" Required - Not sure what it does.
Not sure about the right description here.
Returns:
Empty dict.
"""
# Read commands from the shot file and send them to the device
with h5py.File(self.shot_file, "r") as f:
group = f[f"devices/{self.device_name}"]
if "STOP_COMMANDS" in group:
stop_commands = group["STOP_COMMANDS"][:]
else:
stop_commands = None
for command in stop_commands:
print(f"sending command: {repr(command)}")
self.connection.write(command)
# Forget the shot file:
self.shot_file = None
# This is expected by BLACS to indicate success:
return True
[docs] def shutdown(self):
""" Called when BLACS closes.
"""
self.connection.close()
[docs] def abort_buffered(self):
""" Called when BLACS closes.
Called when a shot is aborted. We may or may not want to run
transition_to_manual in this case. If not, then this method should do whatever
else it needs to, and then return True. It should make sure to clear any state
were storing about this shot (e.g. it should set self.shot_file = None)
"""
return self.transition_to_manual()
[docs] def abort_transition_to_buffered(self):
""" This is called if transition_to_buffered fails with an exception or returns False.
Returns:
True, which indicates success.
"""
# This is called if transition_to_buffered fails with an exception or returns
# False.
# Forget the shot file:
self.shot_file = None
return True # Indicates success


Timeout for completing TCP connections
smtp_connect_timeout
This parameter specifies the SMTP client timeout in seconds for completing a
TCP connection.
When no connection can be made within the deadline, the SMTP client tries the
next address on the mail exchanger list. Specify 0 to disable the timeout.


Travel arrangements
Our travel arrangements include:
Car
Train
Airplane
Horse-drawn carriage
Our patented teleportation service


Arsenal boss Unai Emery told he made a big mistake signing Nicolas Pepe
Arsenal spent a club-record £75million to sign Nicolas Pepe in the summer in a bid to strengthen their attack
by Jake Polden, https://www.mirror.co.uk/authors/jake-polden/Unai Emery made a mistake signing Nicolas Pepe in the summer instead of Harry Maguire.
That's according to Charlton boss Lee Bowyer, who reckons it would have made much more sense for the Gunners to have signed a top centre-back rather than another forward.
Arsenal signing Pepe came as a surprise this summer as the club parted with a record £75million to make the transfer happen.
The Gunners - who did not have the budget to compete with the likes of Manchester City - pulled off the transfer by agreeing to pay Lille in installments.
Maguire, meanwhile, signed for Manchester United in a deal worth £80million.
But Bowyer believes it would have made more sense Arsenal going for the centre-back, as they still look shaky at the back.
"Defensively they are frail, they concede too many goals. Their centre-halves have been a problem for years," said Bowyer on Sky Sports' The Debate.
"It's not just been this season, it's been for a while now, but they would rather spend £75million on a winger than a centre-back.
"Maguire would have been perfect for them, why didn't they get him?"
Arsenal did part with £8million to sign David Luiz from Chelsea, but the Brazilian has done little to shore things up defensively.


30 min meals - Veggie Medley
Autumn Roasted Veggies
Lorem ipsum dolor sit amet consectetur adipisicing elit. Laudantium incidunt architecto, aliquam, repellat beatae soluta aspernatur corrupti adipisci cumque optio iusto rem provident possimus quaerat. Ipsam a quis veniam numquam?
Ingredients
- Butternut Squash
- Tri-colored Radishes
- Carrots
- Sweet Potatoes
- Salt
- Olive Oil
- Rosemary
- Sagee
Recipe Steps
- Cut up veggies into similar size pieces
- Toss in baking dish to coat with oil
- Chop up herbs, use whatever you like or have on hand
- Pre-heat oven to 400 deg.
- Bake for 30 minutes, tossing veggies halfway through
Return to Home Page


HSP : Hot Soup Processor ver3.6 / onion software 1997-2021(c)
This page will be useful for frequently asked questions and many beginners among the questions asked on the HSPTV! Bulletin Board. It is a collection of questions and a list. Please use it together with the manual search and the help browser search. See also HSPWiKi's HSP FAQ ".
error code tells you the cause of the error. The location of the error can also be inferred from the line number.
Copy the DLL or image file to the same directory as the created application.
You may need to modify the script for HSP2 when running it on HSP3. Similarly, you may need to modify the script for HSP3 when running it on HSP2. Check the version of the script on the website that works.
Yes, it is possible.
DLL documentation and follow the instructions.
redraw instruction. At this time, do not use the cls command to clear the screen.
Most keyboards have keys that can be recognized at the same time. This is an unavoidable problem from software.


Xhaka deserves respect – Vieira
by The Eagle OnlineFormer Arsenal captain, Patrick Vieira, has defended Granit Xhaka after the midfielder lost the armband in the wake of his outburst towards the club’s supporters last month.
Xhaka reacted angrily to home fans booing him after he was substituted during Arsenal’s 2-2 draw at the Emirates Stadium and the player has since been left out of the squad.
“I feel sorry for him because he (was) the captain and he’s going through a really difficult period and really difficult time at Arsenal,” Vieira told British media.
He added: “I think we have to remind ourselves that he’s achieved a lot since he’s at Arsenal and he deserves a lot of respect.
 And sometimes you say things or do things you regret.”
Arsenal’s 2-0 loss at Leicester City last weekend left them sixth in the Premier League and put more pressure on coach Unai Emery, who received backing from the club’s hierarchy, but has been told to improve results.
Vieira, who won three league titles with Arsenal, has also urged the supporters to get behind their manager.
“I think he has enough experience to get them through this difficult spell,” Vieira added.
“We have to get behind him and give him time to change things. I am not sure a change of manager will fix the problems.”
Previous Post
Police recruitment: Court adjourns for PSC to respond to AGF’s application
Next Post
FG, Lagos clarify road repairs, allay fears on 3rd Mainland Bridge


Karnataka Bypolls: Narayana Gowda to file nominations
by Gayathri V RajWith Monday (November 18) being the last day for filing nomination papers for the upcoming Karnataka byeelections to be held on December 5, the candidates of all the three major parties Congress, JD(S) and BJP will file nominations from K R Pet Assembly constituency, today.
The candidates who will file for nominations include K C Narayana Gowda, a disqualified MLA is the BJP candidate. BL Devaraj, advocate and KB Chandrasekhar, a former MLA, are contesting from JD (S) and Congress, respectively.
The candidates are expected to take out rallies, accompanied by their respective party leaders, before filing the papers.The rally will be a show of strength for the parties. The supporters have made all arrangements in this regard.
The byeelection to this constituency was necessitated following the resignation of K C Narayana Gowda.


Welcome to RiSiChat 👋
Define your nickname using
$nickname=bob
(bob being the wanted nickname).
anonymous>


Re-size and redraw the grid using the current measurements of its container and viewport.
This will need to be called if you insert your grid into a hidden or off-screen DOM element. You do not need to call this when the browser's window is re-sized -- Doby Grid already automatically detects that.
(object)
- A Doby Grid class instance
new DobyGrid(...).resize();
In this demo, grid.resize will be called automatically as you resize the container:


{% extends "base.html" %} {% block container_block %} Fever Endpoint You should use the address of this page to configure your Fever client. {% endblock %}
You should use the address of this page to configure your Fever client.


{% extends "base.html" %} {% block content %}
To educate the public on the laws of Physics, one step at a time.
Joel Milligan
Leigh Blagden


| Mini_CT Menus |
Mouse Cursor 0.00V
0.00Ma |
Set
|
Run Script For
Fori Wait Line .... |
|
Slow Sweep Start
Step SetSweep Values |
Manual Switch Settings
V Gain
Sense R |
Sweep Control
|
DC Read Voltages VC =
IC = VB = IB = |
|
Display Control
Centering Graphic Buttons
Voltage Offset Current Offset Volts per Div. Amps per Div. Redraw |
Trace Selection
Serial Number
Sweep Step Auto Increment Trace Number Number to Display Plot Type Base V / Base I |
Cursor Functions
|


}
The predictability score for
{% for item in text_output%}
{% set word, color = item%}
{{word}}
{% endfor %}
is
{{score_output}}
Top 10 predicted words (appeared in the first 10 predictions)
Top 100 predicted words (appeared in the first 100 predictions)
Unexpected word (didn't appear in the first 100 predictions)


SHORT CUTS A Film Review Copyright Dragan Antulov 2000
In my country, TV shows dedicated to seventh art tend to be named after great or popular films. Our national television so far had two such shows - one named after A FISTFULL OF DOLLARS and another named after VERTIGO. Local television in my home town adopted the same practices - for the past five or so years, the movie show is named after SHORT CUTS, 1993 drama by Robert Altman. That film perhaps owes such honour mostly to its "cool" title, but it is nevertheless considered to be the one of the most important and most successful films of early 1990s.
The film is based on the short stories by late American writer Raymond Carver. Script by Altman and Frank Barhydt changed the scenery from Pacific Northwest and brought it to Los Angeles where the plot takes place few days before the earthquake. The film actually lacks the plot in the usual sense of the word - instead there are nine vignettes in which we are introduced to few dozen characters. All of those characters are faced with variety of problems which are difficult but mundane - couple must deal with a death of a child, husband has difficulties accepting his wife as phone sex operator, participants in the fishing expedition must decide whether to spoil their fun by reporting dead body to police etc. Those vignettes are connected through characters from one briefly appearing in another and they would all end with the earthquake at the end of the film.
One of the most popular descriptions of SHORT CUTS is "the shortest 3-hour movie in history". This catchphrase, very popular among 1990s critics, seemed impossible for many of those who followed Altman's career a decade earlier. Once one of the most celebrated directors, Altman was practically exiled from Hollywood in the era of Lucas and Spielberg, since everyone began thinking about his films as "too artsy", "hermetic" and incomprehensible to the average viewer. Altman made a comeback with a style in 1992 and got even with Hollywood establishment by mercilessly satire in PLAYER. One year later, Altman finally got his satisfaction by having one of such "artsy" and "hermetic" films being lauded as one of the most important American films in 1990s.
SHORT CUTS in many ways resembles NASHVILLE, another Altman's film populated with myriad of characters and their stories accidentally intertwined on the same place. However, this time Altman doesn't want to use satire in order to expose specific cultural phenomenon (he would do it one year later in PRET-A-PORTER); his goals are more ambitious and he wants to expose modern life in all of its horror. He uses camera as god-like instrument that allows the audience to have insight into the most private and intimate details of protagonist's lives, while in the same time he allows audience powerless to change horrific fates that await some unfortunate individuals in the film. SHORT CUTS is powerful, gripping film in which the black humour often intertwines with tragedy - one of the example is the scene in which a boy gets hit by a car only to refuse the offer of guilt-stricken driver to be taken to hospital, justifying his decision with the most sensible advice given by his parents. Actually, all the misery in this film comes from understandable, down-to-earth human frailties as well as equally down-to- earth and understandable twists of fate.
However, although Altman's masterful hands manage to keep our attention from the beginning till the end, SHORT CUTS doesn't deserve all of the praise received by the critics. Since the material is so diverse, it is natural to expect that some characters and vignettes would work and some would not. Among the latter is the love story between alcoholic Earl (played by Tom Waits) and his long-suffering wife Doreen (played by Lily Tomlin). Quality of acting also varies from vignette to vignette and from character to character. It is interesting to find that the most powerful performances come from a relatively obscure actor like Lyle Lovett, while more established actress like Julianne Moore gets remembered mostly for her willingness to appear partially nude in front of camera. Another distraction in SHORT CUTS comes from rather irritating musical soundtrack by Mark Isham and Gavin Friday, dominated by jazz tunes. However, although SHORT CUTS had its formula later used by other, perhaps even more successful and talented filmmakers, it still provides an interesting viewing experience and clear demonstration of the talent of a very important American filmmaker.
RATING: 7/10 (+++)
Review written on October 4th 2000
Dragan Antulov a.k.a. Drax Fido: 2:381/100 E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>Filmske recenzije na hrvatskom/Movie Reviews in Croatian http://film.purger.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Basic grid-plate demo
This is a whole bunch of paragraphs of text
This is a whole bunch of paragraphs of text
This is a whole bunch of paragraphs of text
This is a whole bunch of paragraphs of text
This is a whole bunch of paragraphs of text


R4 Reference
R4: A SpriteKit in 3D
R4 is a 3D graphics rendering and animation library based on Apple’s SpriteKit Framework. Goal of the library is to ease creation of 3D games and applications by providing the infrastructure whose interface resembles interface of the SpriteKit. Someone who is familiar with SpriteKit shouldn’t have any problems working with this library. Concepts that apply to SpriteKit also apply to R4, just with additional space dimension. R4 is not an extension of the SpriteKit, but a separate library.
The library is in an early phase of the development and lacks some of the SpriteKit’s counterparts, most notably physical subsystem, but it’s usable for the creation of a simple 3D scenes. It provides scene graph infrastructure with drawable nodes like entities and particle emitters, non-drawable nodes like cameras and lights, and scene managers to organize and improve rendering process. Scene nodes are responder objects and can handle touch events defined by the UIResponder class, just like SKNodes.
R4’s rendering system is designed to allow easy extension. Main renderer handles basic viewport configuration, frame buffer management and does scene traversal with a help from the scene manager, but forwards actual drawing responsibility to more extendable and configurable components - materials, techniques and passes. A material encapsulates all information on how to render an object, including all possible ways to do it. A technique describes a way to render an object. It does that by specifying one or more passes that perform rendering. Individual passes do actual rendering using shaders and OpenGL framework.
To learn more about R4 check out Getting started page on Wiki. Continue by reading classes' reference pages. If you’re new to the game development consider reading Apple’s Sprite Kit Programming Guide. It provides great starting point and most of the concepts described there apply to R4.
Features
- SpriteKit based design.
- A node tree based representation of the scene content. See R4Node and R4Scene for more info.
- The nodes are responder objects - they can receive touch events. See R4Node for more info.
- Support for action based animations and logic. See R4Action for more info.
- Particle emitters compatible with Xcode particle editor. See R4EmitterNode for more info.
- OBJ mesh file loader for files that contain one polygon group and one texture. See R4Mesh for more info.
- User-extendable rendering system for custom effects. See R4Material, R4Technique and R4Pass for more info.
Planned or in progress
- Full NSCopying and NSCoding compliance.
- Support for more 3D file formats and extended OBJ file loader.
- Extended collection of R4Action classes.
- Scene and camera transition support based on SKTransition class.
- More out-of-box materials and shaders.
- Basic physical subsystem.
- Skeletal animation.
Requirements
R4 currently supports iOS 7. It can also run on previous versions if you don’t use R4EmitterNode class. Simple scenes can be rendered smoothly on older devices like iPhone 4, but anything more complex will require optimizations like using simpler shaders or lowering drawing resolution to support such devices.
Performance notes
iOS Simulator performs software rendering so you might want to try debugging on the device. If you’re building library by yourself watch for compiler optimizations. There is significant performance difference in doing Debug vs. Release buid.
Getting started
Please check out Getting started page on Wiki.
Contribute
Please check out Contribute page on Wiki.
License
R4 is made available under the MIT License.
Copyright © 2013 Srđan Rašić
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Class References
- R4ADSPass
- R4Action
- R4BasicPass
- R4CameraNode
- R4DefaultSceneManager
- R4DrawState
- R4EmitterNode
- R4EntityNode
- R4LightNode
- R4Material
- R4Mesh
- R4Node
- R4PairKey
- R4ParticlePass
- R4Pass
- R4Program
- R4ProgramManager
- R4Renderer
- R4Scene
- R4Shader
- R4Technique
- R4Texture
- R4TextureInfo
- R4TextureManager
- R4TextureUnit
- R4View
Protocol References
Constant References
- R4BlendMode
- R4CullFace
- R4DeviceCPU
- R4FrontFace
- R4SceneScaleMode
- R4ShaderType
- R4TextureFilteringMode
- R4TextureWrapMode
- R4VertexAttribute


--- subject: newedm --- Let the best shoes fly to you! | Unsubscribe Free Shipping On Orders Over $99 NEW IN SANDALS CLOTHING FLATS&LOAFERS BAGS&ACC SALE
Let the best shoes fly to you! | Unsubscribe
Free Shipping On Orders Over $99
NEW IN
SANDALS
CLOTHING
FLATS&LOAFERS
BAGS&ACC
SALE


subject = "You have been chosen for: {{ project.name }}" ==
Hi {{ user.name }},
Congratulations! Your quote on the project "{{ project.name }}" was chosen by {{ client.display_name }}.
You quoted {% if bid.type == 'fixed' %} {{ bid.fixed_rate|currency }} {% else %} {{ bid.hourly_rate|currency }}/hr {% endif %}
{{ str_limit(bid.details_html, 255) }} {% if bid.details_html|length > 255 %} See more {% endif %}
Click here to open the project page and confirm your acceptance. Be quick to make a decision because {{ client.display_name }} still has the option to pick someone else.
Thanks for using {{ site_name }}!


Configuration Instructions¶
Here we have a little bit of a chicken-and-egg problem. A few of the parameters in the configuration file presume some understanding of the spatial indexing. We will describe the parameters as we encounter them but for a real understanding please refer to later sections.
As we say in the previous section, starting the NExScI TAP service does not require any parameters but of course there are a number of things it needs before it can really do anything. Many of these parameters (such as where to put workspace files and the password to log into the DBMS) cannot be known to the end users.
To consolidate this all in one place, the service reads a number of configuration parameters from a file, found by referring to an environment variable “TAP_CONFIG”. This file is read using the fairly standard ConfigObj package and uses the common INI format, originally from Windows. The data is in simple line-based keyword/value format and has (optionally) section labels (in square brackets). It can be hierarchical, though we don’t need or use that complexity.
We will illustrate our TAP.conf file through a complete example. Note that a number of these parameters can be defaulted, though it is generally a good idea to be explicit for clarity. Be very careful with this file and its permissions; it contains the database password for the TAP user. Risk can be minimized by allowing this user limited access (e.g., read-only to just the TAP-related tables). Still, the file itself should also be read-only access and just from an admin account.:
[webserver]
DBMS=oracle
# DBMS=sqlite3
TAP_WORKDIR=/work
TAP_WORKURL=/workspace
HTTP_URL=http://tapdb.ipac.caltech.edu
HTTP_PORT=80
CGI_PGM=/TAP
# Parameters for cx_Oracle interface
#
[oracle]
ServerName=tapdb
UserID=tap_user
Password=XXXXXXXXXXXX
# Parameters for sqlite3 interface
#
[sqlite3]
DB=/work/sqlite/ps.db
TAP_SCHEMA=/work/sqlite/tap_schema.db
# Spatial indexing settings
#
ADQL_MODE=HTM
ADQL_LEVEL=20
ADQL_XCOL=x
ADQL_YCOL=y
ADQL_ZCOL=z
ADQL_COLNAME=htm20
ADQL_ENCODING=BASE10
In order, here is what each parameter means, starting with the ones describing the machine and service configuration:
DBMS This TAP server potentially supports a wide range of DBMSs (though currently just “oracle” and “sqlite3” are implemented. This parameter specifies the DBMS currently in use and also selects which of the parameter blocks (below) will be used to implement the connection. Here we have selected “oracle” but also show an example (inactive) of an SQLite3 connection.
TAP_WORKDIR This is a the absolute path to the disk space NExScI TAP is supposed to use as working space. It will create a “TAP” subdirectory here and then a collection of temporary, uniquely-named session subdirectories.
TAP_WORKURL The above disk space needs to be URL-accessible (and you have to arrange with your web server to make it so). This is the base URL to the same space.
HTTP_URL A TAP session can involve multiple HTTP connections for various bits of information. So we need the machine address to construct the path to the job status and to the returned data (as well as being part of the original request submission).
HTTP_PORT And the port number as well (often the standard 80).
CGI_PGM Similarly, we need to know how to address the NExScI TAP service executable. By default, this would be something like “/cgi-bin/TAP/nph-tap.py” but you may want to use an alias to streamline the address (we do in this example). Setting that up is again a matter of web server configuration.
For Oracle there are three parameters needed to make a connection. These are well-known quantities you can get from your DBA:
ServerName The core information for making a connection is the “server name” as configured in Oracle.
UserID Once you initiate a connection, you will need a valid user iD.
Password And password. These three parameters are the arguments to the cx_Oracle Python package initialization. cx_Oracle is conformant with the Python DB API 2.0 spec. Other databases will have different detailed connection parameters.
For SQLite3 you need to point to the database files (SQLite3 works using files rather than a daemon process). Since the TAP standard insists on having the TAP_SCHEMA tables in a different schema (in SQLite3 a different file), we have a second parameter for that:
DB SQLite3 database file containing the tables to be served.
TAP_SCHEMA SQLite3 database file containing the five “TAP_SCHEMA” tables.
These files can be stored anywhere you like.
Spatial Indexing Settings. Refer to the indexing documentation for a better understanding. Here we will be terse:
ADQL_MODE We support two sky tesselations for our spatial indexing. Here we are using HTM (Heirarchical Triangular Mesh) as opposed to HPX (HEALPix).
ADQL_LEVEL Any tesselation recurses arbitrarily deeply. The level specifies how deep this is and corresponds to a smallest “cell” size (here HTM 20 cells are about 0.3 arcseconds on a side).
ADQL_COLNAME For our custom spatial indexing to work, tables need to include the index value column explicitly. The obvious name here would be “htm20” (it is for us) but you may have some reason to use another name.
ADQL_ENCODING This one is arcane and only really applies to HTM in practice. Since tesselations are based on recursive decomposition of spatial cells into four, sometimes (and mostly for debugging) it is nice to have database values be base 4 numbers. But this increases the number of digits by a fair bit and normally regular base 10 numbers are easier to store. Supported values are therefore “BASE10” and “BASE4”.
ADQL_XCOL The spatial indexing cell numbers allow very quick subsetting but the results are only approximate (i.e. some of the records in a “matching” cell are outside the exact geometry defined; like a cone on the sky). Including the (x,y,z) geometric tree-vector coordinates of the location allow us to perform an exact secondary filter of the data. Again, you may not want to use the name ‘x’ for this x-column so we let you set the name explicitly here.
ADQL_YCOL Ditto for the y-column name.
ADQL_ZCOL And the z-column name.


I recently participated in the Kaggle-hosted data science competition How Much Did It Rain II where the goal was to predict a set of hourly rainfall levels from sequences of weather radar measurements. I came in first! I describe my approach in this blog post.
My research lab supervisor Dr John Pinney and I were in the midst of developing a set of deep learning tools for our current research programme when this competition came along. Due to some overlaps in the statistical tools and data sets (neural networks and variable-length sequences, in particular) I saw it as a good opportunity to validate some of our ideas in a different context (at least that is my post hoc justification for the time spent on this competition!). In the near future I will post about the research project and how it relates to this problem.
One of things which inspired me to write this up, other than doing well in the competition, was the awesome blog post by Sander Dieleman where he describes his team’s winning approach in another Kaggle competition I took part in. So following the outline of that article, here’s my solution to this problem.
Introduction
The problem
The goal of the competition was to use sequences of polarmetric weather radar data to predict a set of hourly rain gauge measurements recorded over several months in 2014 over the US midwestern corn-growing states. These radar readings represent instantaneous precipitation rates and is used to estimate rainfall levels over a wider area (e.g. nationwide) than can practically be covered by rain gauges.
For the contest, each radar measurement was condensed into 22 features. These include the minutes past the top of the hour that the radar observation was carried out, the distance of the rain gauge from the radar, and various reflectivity and differential phase readings of both the vertical column above and the areas surrounding the rain gauge. Up to 19 radar records are given per hourly rain gauge reading (and as few as a single record); interestingly the number of radar measurements provided should itself contain some information on the rainfall levels as it is apparently not uncommon for meteorologists to request multiple radar sweeps when there are fast-moving storms.
The preditions were evaluated based on the mean absolute error (MAE) relative to actual rain gauge readings.
The solution: Recurrent Neural Networks
The prediction of cumulative values from variable-length sequences of vectors with a ‘time’ component is highly reminiscent of the so-called Adding Problem in machine learning—a toy sequence regression task that is designed to demonstrate the power of recurrent neural networks (RNN) in learning long-term dependencies (see Le et al., Sec. 4.1, for a recent example):
In our rainfall prediction problem, the situation is somewhat less trivial as there is still the additional step of inferring the rainfall ‘numbers’ (the top row) from radar measurements. Furthermore, instead of binary 0/1 values (bottom row) one has continuous time readings between 0 and 60 minutes that have somewhat different roles. Nevertheless, the underlying structural similarities are compelling enough to suggest that RNNs are well-suited for the problem.
In the previous version of this contest (which I did not participate in), gradient boosting was the undisputed star of the show; neural networks, to my knowledge, were not deployed with much success. If RNNs would prove to be as unreasonably effective here as they are in an increasing array of problems in machine learning, then I might have a chance of coming up with a unique and good solution.
For a overview of RNNs, the blog post by Andrej Karpathy is as good a general introduction to the subject as you will find anywhere.
Software and hardware
I used Python with Theano throughout and relied heavily on the Lasagne layer classes to build the RNN architectures. Additionally, I used scikit-learn to implement the cross-validation splits, and pandas and NumPy to process and format the data and submission files. To this day I have an irrational aversion to Matplotlib (even with Seaborn) and so all my plots were done in R.
I trained the models on several NVIDIA GPUs in my lab, which include two Tesla K20 and three M2090 cards.
The data
Pre-processing
From the outset, there were several challenges brought about by certain features of the data:
-
Extreme and unpredictable outliers
-
Variable sequence lengths and irregular radar measurement times
-
A training set with non-independently distributed samples
Extreme and unpredictable outliers
It was well-documented from the start, and much discussed in the competition forum, that a large proportion of the hourly rain gauge measurements were not to be trusted (e.g. clogged rain gauges). Given that some of these values are several orders of magnitude higher than what is physically possible anywhere on earth, the MAE values participants were reporting were dominated by these extreme outliers. However, since the evaluation metric was the MAE rather than the root-mean-square error (RMSE), one can simply view the outliers as an annoying source of extrinsic noise in the evaluation scores; the absolute values of the MAE are however, in my view, close to meaningless without prior knowledge of typical weather patterns in the US midwest.
The approach I and many others took was simply to exclude from the training set the rain gauges with readings above 70mm. Over the course of the competition I experimented with several different thresholds from 53mm to 73mm, and did a few runs where I removed this pre-processing step altogether. Contrary to what was reported in the previous version of this competition, this had very little effect on the performance of the model (positive or negative); it appears, and I speculate, that the RNN models had learnt to ignore the outliers, as suggested by the very reasonable maximum values of expected hourly rain gauge levels predicted for the test set (~45-55mm).
Variable sequence lengths and irregular radar measurement times
The weather radar sequences varied in length from one to 19 readings per hourly rain gauge record. Furthermore these readings were taken at seemingly random points within the hour. In other words, this was not your typical time-series dataset (EEG waveforms, daily stock market prices, etc).
One attractive feature of RNNs is that they accept input sequences of varying lengths due to weight sharing in the hidden layers. Because of this, I did not do any pre-processing beyond removing the outliers (as described above) and replacing any missing radar feature values with zero; I retained each timestamp as a component in the feature vector and preserved the sequential nature of the input. The idea was to implement an end-to-end learning framework and, for this reason, with not a small touch of laziness thrown in, I did not bother to implement any feature engineering.
A training set with non-independently distributed samples
The training set consists of data from the first 20 days of each month and the test set data from the remaining days. This ensures that both sets are more or less independent. However, as was pointed out in the competition forum, because the calendar time and location information is omitted, it is impossible to construct a local validation holdout subset that is truly independent from the rest of the training set; specifically, there is no way of ensuring that any two gauge readings are not correlated in time or space. This had implications in that it was very difficult to detect cases of overfitting without submissions to the public leaderboard (see Training section below for more details).
Data augmentation
One common method to reduce overfitting is to augment the training set via label-preserving transformations on the data. The classic examples in image classification tasks include cropping and shifting the images, and in many cases rotating, perturbing the brightness and colour of the images and introducing noise.
For the radar sequence data, I implemented a form of Dropin augmentation on the data where the sequences were lengthened to a fixed length in the time dimension by duplicating the vectors at random time points. This is loosely speaking the opposite of performing dropout on the input layer, hence the name. This is illustrated in the figure below:
Over the competition I experimented with fixed sequence lengths of 19, 21, 24 and 32 timepoints. I found that stretching out the sequence lengths beyond 21 timesteps was too aggressive as the models began to underfit.
My original intention was to find a way to standardise the sequence lengths to facilitate mini-batch stochastic gradient descent training. However it soon became clear that it could be a useful way to force the network to learn to factor in the time intervals between observations; specifically, this is achieved by encouraging the network to ignore readings when the intervals are zero. To the best of my knowledge this is a novel, albeit simple, idea.
RNN architecture
The best performing architecture I found over the competition is a 5-layer deep stacked bidirectional (vanilla) RNN with 64-256 hidden units, with additional single dense layers after each hidden stack. At the top of the network the vector at each time position is fed into a dense layer with a single output and a Rectified Linear Unit (ReLU) non-linearity. The final result is obtained by taking the mean of the predictions from the entire top layer. I will explain the evolution of this model using figures in the following section. This roughly mirrors the way I developed the models over the course of the competition.
Design evolution
The basic model inspired by the adding problem is a single layer RNN:
The RNN basically functions as an integration machine and is employed in a many-to-one fashion.
The law of gravity aside, and not to mention the second law of thermodynamics, there is nothing preventing us from viewing the problem as rain flying up from rain gauges on the ground and reconstituting itself as clouds. Hence we can introduce a reverse direction and consider a bidirectional RNN:
A separate class of architectures imagines predictors situated across the time dimension at the top of the network, each with a unique view to the past and the future. In this scenario we pool together the outputs from the entire hidden layer to obtain a consensus prediction:
Finally, there are all manner of enhancements one can employ to create a deep network such as stacking and inserting dense layers between stacks and at the top of the network (see Pascanu et al.). In addition to these I included a linear layer to reduce the dimension of the feature vectors from 22 to 16, in part to guard against overfitting and partly because the models were beginning to take too long to train (see below):
I actually started out with Long-Short Term Memory (LSTM) units but, in order to reduce the training time, switched to ordinary RNNs with fully connected layers, which turned out to be just as effective. My guess is that the advantages of LSTMs are only really apparent for much longer sequences than the radar sequences in this competition.
The final structural idea was to pass the top layer of the network, or perhaps the input layer itself, through a set of 1D convolutional and pooling layers. The motivation for this, other than the irresistable urge to throw the neural network equivalent of the kitchen sink at any and every problem, was the notion of temporal invariance—that the rain collecting in gauges should contribute the same amount to the hourly total regardless of when in the hour it actually entered the rain gauge. In my half-hearted attempt at this, my models unfortunately performed worse and I promptly abandoned it.
Nonlinearities
I used ReLUs throughout with varying amounts of leakiness in the range 0.0-0.5. The goal was not to optimise this hyperparameter but to increase the variance in the final ensemble of models. Nevertheless I did find that using the original ReLU with no leakiness often resulted in very poor convergence behaviours (i.e. no improvement at all).
Training
Local validation
I began by splitting off 20% of the training set into a stratified (with respect to the number of radar observations) validation holdout set. I soon began to distrust my setup as some models were severely overfitting on the public leaderboard despite improving local validation scores. By the end of the competition I was training my models using the entire training set and relying on the very limited number of public test submissions (two per day) to validate the models, which is exactly what one is often discouraged from doing! Due to the nature of the training and test sets in this competition (see above), I believe it was the right thing to do.
Training procedure
I used stochastic gradient descent (SGD) with the Adadelta update rule with a learning rate decay.
I employed mini-batches of size 64 throughout; I found that the models performed consistently worse for sizes of 128 and higher, possibly because the probability of having mini-batches without any of the extreme outliers became very small. I did not get the time to properly investigate this.
Each model was trained over approximately 60 epochs and, depending on the size of the model, the training times ranged from one to five days per model.
Initialisation
Most of the models used the default weight initialisation settings of the Lasagne layer classes. Towards the end of the competition I experimented with the normalized-positive definite weight matrix initialisations proposed in Talathi et al. but found no significant effect on the performances.
Regularisation
My biggest surprise was that implementing dropout resulted in consistently poorer results, contrary to what had been reported by many others, such as in Zaremba et al.. I tried many combinations, including varying the dropout percentage and implementing it only at the top and/or bottom of the network, all without success. This is in stark contrast to the effectiveness of dropout when employed in the fully connected layers of CNN architectures.
For this reason, in the limited time available, I did not bother with weight decay as I reasoned that my main issue was under- rather than overfitting the data.
Model ensembles
Test-time augmentation
To predict each expected rainfall value, I took the mean of 61 separate rain gauge predictions that were generated from different dropin augmentations of the radar data sequence. Implementing this procedure led to a large improvement (~0.03) in the public leaderboard score.
Averaging models
The winning submission was a simple weighted average of 30 separate models. The best model had a public leaderboard score of 23.6971, which should be good enough for fifth place; the worst score in the winning ensemble was 23.7123. The weights were chosen on the basis of a wholly unscientific combination of public leaderboard scores and correlations between the different sets of predictions. Given the difficulties in constructing truly independent splits of the training set, there is no guarantee that the more sophisticated ensembling techniques such as stacked generalisation would be any more effective.
Final thoughts
If I were to take one point away from this contest, it is that the days of manually constructing features from data are almost over. The machines will win. I experienced this in the Plankton classification contest where the monumental effort that my teammate and I put into extracting image features was eclipsed within minutes by even the shallowest of CNNs.
I had lots of fun in this contest and have learnt a lot. Congratulations to the other winners, and special thanks to the competition organisers and sponsors. I will make my code available soon. If you have any questions or comments, please feel free to share them.
UPDATE (2 Jan 2016): The code is now available on GitHub: https://github.com/simaaron/kaggle-Rain


Server-Sent Events tab
The Server-Sent Events tab displays all events from event streams.
Još vidjeti
Basic Server-Sent Events concepts
for a short introduction to Server-Sent Events


T1A02-forms-Evan
Survey
First name:
Last name:
Password:
E-mail:
Fill in every answer you can.
Please select your level of schooling
Middle School
High/Secondary School
University/ Collage
Birthday:
Select what area you live in.
Urban
Suburban
Rural
Select your favorite color:
Male
Female
Other
Submit


{% extends "base.html" %} {% block title %} U.N. Universal Period Review - Edit Submission {% endblock title %} {% block content %} Merge with? Orgnization Name Personal Organization UN Professional Complaint Title Personal Organization UN Professional I understand that I can no longer edit after merging Submit Update a UPR Complaint Complaint # Complaint Title Authors Country Date Submitted Additions Made Options 1 LGBTQ Human Rights Issues Deep Datta United States 08/29/2016 ... Edit Merge 2 Edit Merge 3 Edit Merge 4 Edit Merge 5 Edit Merge 6 Edit Merge 7 Edit Merge 8 Edit Merge 9 Edit Merge {% endblock content %}


When we are struggling with harsh realities or simply the monotony of daily life, praising God is often not at the top of our list of things we feel like doing. But our need to worship God does not change with our shifting circumstances. Daniel made worship a habit. If we will do the same, we will find that praise grounds us in a reality beyond our moods or our situations. Worship gives deep gladness to the heart of God. It also grounds us in a reality that is unseen—one that is more true than those before our eyes.
How does offering praise and worship affect or change you?
Daniel found a place to worship even when it wasn’t convenient or safe. He prayed to God when he may have felt very distant from God. This daily practice of prayer and worship helped Daniel and his friends keep their faith strong when faced with tough choices. Daniel’s prayer life and his ability to stay true to God, continuing to worship even when it meant his life was at stake, are intrinsically connected. His continual seeking of God’s heart through worship helped him do what was right even when the stakes were high.
Reread Daniel 6:11-16. What was the consequence of Daniel’s decision to disobey the king’s decree?
Don’t miss this: Worship prepared Daniel to face the lions’ den.
God knew that worship would be as important to us as the air we breathe. When we’re living in an atmosphere that could choke the faith out of us, making worship a priority is as important as taking oxygen on a deep-sea diving expedition.
The emphasis on worship is found throughout Scripture. The Psalms are packed with praise and worship to God. Revelation shines with Technicolor images of worship before the lamb on the throne. The book of Exodus dedicates thirteen chapters to instructions about the building of the Tabernacle, a traveling center of worship for God’s people. The attention given to worship in so many situations in the Bible shows us how important worship is to God.
What do you discover about the importance of worship in these different situations in Scripture?


vegetation climate changes period human change types distribution global land potential Zhang data disturbance existing &\displaystyle NDVI {border-style px;} #ffffff;} Ellis Fig. China use \vdots forest Climate Global monthly Yan regions Liu influences mean DeFries \cdots based influence using Science caused eastern grid mainly transformed Allen Change Ramankutty \displaystyle climatic detected differences px; reflected tree {font-family However, National Nature activities anthropogenic cells changed cover disturbances font-size influenced studies study used vegetation. Breshears Chen Figure Foley Human International area biomes double; effects occurred past resolution total transformation transformations tropical type types. (C) (e.g., America Goldewijk Remote Research States Tucker United Vegetation Yan, border-color border-width change. classification classified dataset drought forests large limited results similar solid; temperature warming western {font-style {font-weight (). (A) (B) ./j.-...x ./s--- AVHRR Beck Box China, Climatology Diaz Ecology Geographical Holdridge Kottek Loveland NIR North PeerJ Pinzon Price RED Sciences Sensing Song Townshend Van a). activity bold central changes, compared contributions courier; defined degradation em; human-induced identified likely mortality new number polar population pt;} regions. restoration result shifts southern stronger terrestrial world


The current process to develop, conduct, and analyze usability tests is too costly for the company to sustain.
The first step in solving this problem was identifying, in detail, all of the steps involved in the current usability testing process.
Given that this organization is a non-profit, and the usability testing feature is a free supplement that clients can decide to participate in, the budget for our project was very strict. So, we had to interview the employees of Data Driven Detroit (D3) to generate concrete numbers for each area that contributed to the overall cost.
To disambiguate the procedure, our team put together an infographic to clearly define each step within the Citizen Usability Testing Group (CUTgroup) process.
Once our group laid out each step, we had to identify points in which there was potential to cut expenses.
To do so, we brainstormed dozens of ideas and targeted the most plausible ones to continue with.
After discussing the pros and cons of each potential solution, our team decided on five categories of ideas to cut expenses. Those categories included immediate fixes, user test templates, remote testing, division of labor, and student involvement.
I personally took a leadership role in developing the division of labor aspect, as the current process at D3 involved one employee fulfilling the majority of the tasks. In my proposed solution, the creation of usability testing questions, analysis of data, and generation of the report would be spread out amongst multiple company members. This allows people to specialize in their area of expertise and also cuts down on the overall time for the report to return to the client.
The final step before creating our deliverable was listing out in-depth pros and cons for each proposed solution. This involved noting the stakeholders involved for each option and how the interests of the company would be fulfilled.
Our final deliverable was a presentation to Data Driven Detroit executives that discussed our proposed solutions for cutting costs in their Usability Testing process. Our efforts in this project resulted in a concrete procedure for conducting usability tests in a more sustainable, efficient way to save costs for the company.
Connect university students with clients trying to conduct usability tests to give students experience and provide client with results. Simultaneously, template usability testing for desired focus, divide tasks between team members, and conduct some tests remotely.


24
1 These are the divisions of the descendants of Aaron the first high priest: Aaron's four sons were Nadab, Abihu, Eleazar, and Ithamar.
2 But Nadab and Abihu died before their father died, and they had no children. So their younger brothers Eleazar and Ithamar became the priests.
3 Zadok, who was a descendant of Eleazar, and Ahimelech, who was a descendant of Ithamar, helped David to separate the family groups into two groups. Each group had certain duties.
4 There were more leaders among the descendants of Eleazar than there were among the descendants of Ithamar. So they appointed sixteen leaders from Eleazar's descendants and eight leaders from Ithamar's descendants.
5 There were temple officials and priests who were there, including descendants of both Eleazar and Ithamar, to make sure that the work was divided fairly. So they decided what work each group would do by casting lots.
6 Shemaiah son of Nethanel, who was a descendant of Levi, wrote down the names of the leaders of each group while David and his officials were watching. Zadok, the high priest, and Ahimelech his assistant, and the leaders of the families of the priests and of the families of the other descendants of Levi also watched.
7 Jehoiarib was the first one whose name was selected by casting lots.
Next Jedaiah was selected.
8 Next, Harim was selected.
Next, Seorim was selected.
9 Next, Malkijah was selected.
Next, Mijamin was selected.
10 Next, Hakkoz was selected.
Next, Abijah was selected.
11 Next, Jeshua was selected.
Next, Shecaniah was selected.
12 Next, Eliashib was selected.
Next, Jakim was selected.
13 Next, Huppah was selected.
Next, Jeshebeab was selected.
14 Next, Bilgah was selected.
Next, Immer was selected.
15 Next, Hezir was selected.
Next, Happizzez was selected.
16 Next, Pethahiah was selected.
Next, Jehezkel was selected.
17 Next, Jakin was selected.
Next, Gamul was selected.
18 Next, Delaiah was selected.
Next, Maaziah was selected.
19 Those were the men who were chosen to be the leaders of the groups that would serve in the temple, obeying the regulations that were set down by Aaron, regulations which Yahweh, the God to whom we Israelite people belong, had given to him.
20 This is a list of some of the other descendants of Levi:
From the sons of Amram there was Shubael.
From the sons of Shubael there was Jehdeiah.
21 From Rehabiah son of Eleazar there was Isshiah, his oldest son.
22 From the descendants of Kohath's son Izhar there was Shelomoth.
From the descendants of Shelomoth there was Jahath.
23 From the descendants of Kohath's son Hebron there was his oldest son Jeriah and Jeriah's younger brothers Amariah, Jahaziel, and Jekameam.
24 From the descendants of Kohath's son Uzziel there was Micah.
From the descendants of Micah there was Shamir.
25 And Micah's younger brother was Isshiah.
From the descendants of Isshiah was Zechariah.
26 The sons of Merari were Mahli, Mushi, and Jaaziah.
27 From the descendants of Jaaziah there were Beno, Shoham, Zaccur, and Ibri.
28 Mahli's son Eleazar did not have any sons.
29 From the descendants of Kish there was his son Jerahmeel.
30 The sons of Mushi were Mahli, Eder, and Jerimoth.
Those were descendants of Levi who were listed according to the leaders of their families.
31 The jobs they would do were decided by casting lots like their fellow Israelites the descendants of Aaron, did. They cast lots while King David, Zadok, Ahimelech, and the leaders of he families of the priests and the other descendants of Levi watched. The jobs that were given to the families of each oldest brother and each youngest brother were equal.


GitHub Introduction
Github is a provider of Internet hosting for software development and version control using Git. It offers the distributed version control and source code management functionality of Git. It is a website and cloud-based service that allows developers to store and manage their code, as well as track changes to their code, and it also allows you to host public accessible static web-pages.
Click to enterFeatures of GitHub
- Collaborative Coding
- Automation and CI/CD
- Security
- Client Apps
- Project Management
- Team Administration
- Community
Steps
- Login your Github account
- Start a project and create a Repository(example: EP1000)
- In the Repository, find setting then Github pages, change source, from none to master branch
- Upload, drag and drop your web page written in HTML (example: index.html OR mypage.html)
Now you should have your website and everyone can see, just enter https://(name).github.io/(repository name)/ , you should able to see own design web page.


This is a demo for real-time image recognition using Kafka and Spark Streaming. Check out the Channels dropdown menu to see examples of live processing in action.


|
Ext.NET Mobile
4.1.0
.NET Component Framework for Enterprise Level Apps
|
Public Member Functions | |
| Builder (TTitleBar component) | |
| virtual TBuilder | MaxButtonWidth (string maxButtonWidth) |
| The maximum width of the button by percentage. Defaults to: '40' More... | |
| virtual TBuilder | Title (string title) |
| The title of the toolbar. Defaults to: null More... | |
| virtual TBuilder | TitleAlign (TitleAlign titleAlign) |
| The alignment for the title of the toolbar. Defaults to: 'center'. More... | |
| virtual TBuilder | UI (TitleBarUI uI) |
| Style options for Toolbar. Either 'light' or 'dark'. Defaults to: 'dark' More... | |
| virtual TBuilder | SetMaxButtonWidth (string width) |
| virtual TBuilder | SetTitle (string title) |
| virtual TBuilder | SetTitleAligh (TitleAlign titleAlign) |
| virtual TBuilder | SetUI (TitleBarUI ui) |
| Builder () | |
| Builder (TitleBar component) | |
| Builder (TitleBar.Config config) | |
| Public Member Functions inherited from Ext.Net.Mobile.Container.Builder< TTitleBar, TBuilder > | |
| Builder (TContainer component) | |
| Builder () | |
| Builder (Container component) | |
| Builder (Container.Config config) | |
| virtual TBuilder | Listeners (Action< ContainerListeners > action) |
| Client-side JavaScript Event Handlers More... | |
| virtual TBuilder | DirectEvents (Action< ContainerDirectEvents > action) |
| Server-side Ajax Event Handlers More... | |
Static Public Member Functions | |
| static implicit | operator Builder (TitleBar component) |
| Static Public Member Functions inherited from Ext.Net.Mobile.Container.Builder< TTitleBar, TBuilder > | |
| static implicit | operator Builder (Container component) |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinevirtual |
The maximum width of the button by percentage. Defaults to: '40'
|
inlinestatic |
|
inlinevirtual |
|
inlinevirtual |
|
inlinevirtual |
|
inlinevirtual |
|
inlinevirtual |
The title of the toolbar. Defaults to: null
|
inlinevirtual |
The alignment for the title of the toolbar. Defaults to: 'center'.
|
inlinevirtual |
Style options for Toolbar. Either 'light' or 'dark'. Defaults to: 'dark'


The following example shows how to transcribe an audio file using Cubic’s Streaming Recognize Request. The stream can come from a file on disk or be directly from a microphone in real time.
We support several file formats including WAV, MP3, FLAC etc. For more details, please
see the protocol buffer specification file in the SDK repository (grpc/cubic.proto
).
The examples below use a WAV file as input to the streaming recognition. We will query
the server for available models and use the first model to transcribe the speech.
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/cobaltspeech/sdk-cubic/grpc/go-cubic"
"github.com/cobaltspeech/sdk-cubic/grpc/go-cubic/cubicpb"
)
const serverAddr = "<IP_ADDRESS>:2727"
func main() {
client, err := cubic.NewClient(serverAddr)
if err != nil {
log.Fatal(err)
}
defer client.Close()
modelResp, err := client.ListModels(context.Background())
if err != nil {
log.Fatal(err)
}
// Use the first available model
model := modelResp.Models[0]
f, err := os.Open("test.wav")
if err != nil {
log.Fatal(err)
}
defer f.Close()
cfg := &cubicpb.RecognitionConfig{
ModelId: model.Id,
}
// Define a callback function to handle results
resultHandler := func(resp *cubicpb.RecognitionResponse) {
for _, r := range resp.Results {
if !r.IsPartial {
fmt.Println(r.Alternatives[0].Transcript)
}
}
}
err = client.StreamingRecognize(context.Background(), cfg, f, resultHandler)
if err != nil {
log.Fatal(err)
}
}
import cubic
serverAddress = '<IP_ADDRESS>:2727'
client = cubic.Client(serverAddress)
# get list of available models
modelResp = client.ListModels()
for model in modelResp.models:
print("ID = {}, Name = {}".format(model.id, model.name))
# use the first available model
model = modelResp.models[0]
cfg = cubic.RecognitionConfig(
model_id = model.id
)
# client.StreamingRecognize takes any binary
# stream object that has a read(nBytes) method.
# The method should return nBytes from the stream.
# open audio file stream
audio = open('test.wav', 'rb')
# send streaming request to cubic and
# print out results as they come in
for resp in client.StreamingRecognize(cfg, audio):
for result in resp.results:
if result.is_partial:
print("\r{0}".format(result.alternatives[0].transcript), end="")
else:
print("\r{0}".format(result.alternatives[0].transcript), end="\n")
// Initialize a gRPC connection
var creds = Grpc.Core.ChannelCredentials.Insecure;
var channel = new Grpc.Core.Channel(url, creds);
var client = new CobaltSpeech.Cubic.Cubic.CubicClient(channel);
// List the available models
var listModelsRequest = new CobaltSpeech.Cubic.ListModelsRequest();
var models = client.ListModels(listModelsRequest);
// Setup the bi-directional gRPC stream.
var call = client.StreamingRecognize();
using (call)
{
// Setup recieve task
var responseReaderTask = Task.Run(async () =>
{
// Wait for the next response
while (await call.ResponseStream.MoveNext())
{
var response = call.ResponseStream.Current;
foreach (var result in response.Results)
{
Console.WriteLine(result.Alternatives[0].Transcript);
}
}
});
// Send config first, followed by the audio
{
// Send the configs
var request = new CobaltSpeech.Cubic.StreamingRecognizeRequest();
request.Config = cfg;
await call.RequestStream.WriteAsync(request);
// Setup object for streaming audio
request.Config = null;
request.Audio = new CobaltSpeech.Cubic.RecognitionAudio { };
// Send the audio, in 8kb chunks
const int chunkSize = 8192;
using (FileStream file = File.OpenRead("test.raw"))
{
int bytesRead;
var buffer = new byte[chunkSize];
while ((bytesRead = file.Read(buffer, 0, buffer.Length)) > 0)
{
var bytes = Google.Protobuf.ByteString.CopyFrom(buffer);
request.Audio.Data = bytes;
await call.RequestStream.WriteAsync(request);
}
// Close the sending stream
await call.RequestStream.CompleteAsync();
}
}
// Wait for all of the responses to come back through the receiving stream
await responseReaderTask;
}
Please note: this example does not attempt to handle threading and all exceptions. It gives a simplified overview of the essential gRPC calls.
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;
import com.google.protobuf.ByteString;
import com.cobaltspeech.cubic.CubicGrpc;
import com.cobaltspeech.cubic.CubicOuterClass.*;
public static void transcribeFile() {
// Setup connection
CubicGrpc.CubicStub mCubicService = CubicGrpc.newStub(
ManagedChannelBuilder.forTarget(url).build());
// Setup callback to handle results
StreamObserver<> responseObserver = new StreamObserver<RecognitionResponse>() {
@Override
public void onNext(RecognitionResponse value) {
System.out.println("Result: " + value.toString());
}
@Override
public void onError(Throwable t) {
System.err.println("Error with recognition:" + t.toString());
}
@Override
public void onCompleted() {
System.out.println("Server is done sending responses back");
}
};
// Setup bidirectional stream
StreamObserver<StreamingRecognizeRequest> requestObserver; // Outgoing messages are sent on this request object
requestObserver = mCubicService.streamingRecognize(mRecognitionResponseObserver);
// Send config message
StreamingRecognizeRequest configs = StreamingRecognizeRequest.newBuilder()
// Note, we do not call setAudio here.
.setConfig(RecognitionConfig.newBuilder()
.setModelId("ModelID")
.build())
.build();
requestObserver.onNext(configs);
// Read the file in chunks and stream to server.
try {
FileInputStream is = new FileInputStream(new File("/path/to/file"));
byte[] bytes = new byte[1024];
int len = 0;
// Read the file
while ((len = is.read(chunk)) != -1) {
// Convert byte[] to ByteString for gRPC
ByteString audioBS = ByteString.copyFrom(chunk);
// Send audio to server
RecognitionAudio audioMsg = RecognitionAudio.newBuilder()
.setData(audioBS)
.build()
requestObserver.onNext(StreamingRecognizeRequest.newBuilder()
.setAudio(audioMsg)
.build());
}
} catch (Exception e) { } // Handle exception
// Close the client side stream
requestObserver.onCompleted();
// Note: Once the server is done transcribing everything, responseObserver.onCompleted() will be called.
}
Streaming audio from microphone input typically needs us to interact with system libraries. There are several options available, and although the examples here use one, you may choose to use an alternative as long as the recording audio format is chosen correctly.
This example utilizes the portaudio bindings for Go
to stream audio from a microphone. To use this package, install PortAudio
development headers and libraries using an appropriate package manager for your system (e.g. apt-get install portaudio19-dev
on Ubuntu, brew install portaudio
for OSX, etc.) or build from source.
package main
import (
"bytes"
"context"
"encoding/binary"
"fmt"
"log"
"github.com/cobaltspeech/sdk-cubic/grpc/go-cubic"
"github.com/cobaltspeech/sdk-cubic/grpc/go-cubic/cubicpb"
"github.com/gordonklaus/portaudio"
)
const serverAddr = "<IP_ADDRESS>:2727"
// Microphone implements the io.ReadCloser interface and provides
// a data stream for microphone input.
type Microphone struct {
buffer []int16
stream *portaudio.Stream
}
// NewMicrophone instantiates a Microphone object with the desired
// sampling rate and buffer size. When streaming to cubic, the sample
// rate should be set to the sample rate of the model used.
func NewMicrophone(sampleRate, bufferSize uint32) (*Microphone, error) {
// bufferSize is measured in number of bytes. Since we are capturing
// 16 bit audio, each sample is 2 bytes. The microphone has a int16
// buffer, so we use the number of samples as its size.
numSamples := bufferSize/2
mic := Microphone{buffer: make([]int16, numSamples)}
portaudio.Initialize()
stream, err := portaudio.OpenDefaultStream(1, 0, float64(sampleRate), int(numSamples), mic.buffer)
if err != nil {
return nil, err
}
mic.stream = stream
err = mic.stream.Start()
if err != nil {
return nil, err
}
return &mic, nil
}
// Read copies N bytes into the passed buffer from the microphone audio buffer
// where N is the buffer size passed to `cubic.NewClient`. Also, to be compatible
// with the cubic client, it returns two things : an int representing the number of
// bytes copied and an error.
func (mic *Microphone) Read(buffer []byte) (int, error) {
err := mic.stream.Read()
if err != nil {
return 0, err
}
byteBuffer := new(bytes.Buffer)
err = binary.Write(byteBuffer, binary.LittleEndian, mic.buffer)
if err != nil {
return 0, err
}
copy(buffer, byteBuffer.Bytes())
return len(buffer), nil
}
// Close shuts the microphone stream down and cleans up
func (mic *Microphone) Close() {
mic.stream.Stop()
mic.stream.Close()
portaudio.Terminate()
}
func main() {
bufferSize := uint32(8192)
client, err := cubic.NewClient(serverAddr, cubic.WithInsecure(), cubic.WithStreamingBufferSize(bufferSize))
if err != nil {
log.Fatal(err)
}
defer client.Close()
modelResp, err := client.ListModels(context.Background())
if err != nil {
log.Fatal(err)
}
// Use the first available model
model := modelResp.Models[0]
cfg := &cubicpb.RecognitionConfig{
ModelId: model.Id,
}
// Define a callback function to handle results
resultHandler := func(resp *cubicpb.RecognitionResponse) {
for _, r := range resp.Results {
if r.IsPartial {
fmt.Print("\r", r.Alternatives[0].Transcript) // print on same line
} else {
fmt.Println("\r", r.Alternatives[0].Transcript) // print and move to new line
}
}
}
// Create microphone stream
mic, err := NewMicrophone(model.Attributes.SampleRate, bufferSize)
if err != nil {
log.Fatal(err)
}
defer mic.Close()
// Since Microphone implements the io.ReadCloser interface, we can
// pass it directly to the StreamingRecognize function.
err = client.StreamingRecognize(context.Background(), cfg, mic, resultHandler)
if err != nil {
log.Fatal(err)
}
}
This example requires the pyaudio
module to stream audio from a microphone. Instructions for installing pyaudio for
different systems are available at the link. On most platforms, this is simply pip install pyaudio
.
import cubic
import pyaudio
serverAddress = '<IP_ADDRESS>:2727'
client = cubic.Client(serverAddress)
# get list of available models
modelResp = client.ListModels()
# use the first available model
model = modelResp.models[0]
cfg = cubic.RecognitionConfig(
model_id = model.id
)
# client.StreamingRecognize takes any binary stream object that has a read(nBytes)
# method. The method should return nBytes from the stream. So pyaudio is a suitable
# library to use here for streaming audio from the microphone. Other libraries or
# modules may also be used as long as they have the read method or have been wrapped
# to do so.
# open microphone stream
p = pyaudio.PyAudio()
audio = p.open(format=pyaudio.paInt16, # 16 bit samples
channels=1, # mono audio
rate=model.attributes.sample_rate, # sample rate in hertz
input=True) # audio input stream
# send streaming request to cubic and
# print out results as they come in
try:
for resp in client.StreamingRecognize(cfg, audio):
for result in resp.results:
if result.is_partial:
print("\r{0}".format(result.alternatives[0].transcript), end="")
else:
print("\r{0}".format(result.alternatives[0].transcript), end="\n")
except KeyboardInterrupt:
# stop streaming when ctrl+C pressed
pass
except Exception as err:
print("Error while trying to stream audio : {}".format(err))
audio.stop_stream()
audio.close()
We do not currently have example C# code for streaming from a microphone.
Simply pass the bytes from the microphone the same as is done from the file in the Streaming from an audio file
example above.
This example uses the android.media.AudioRecord
class and assumes the min API level is higher than Marshmallow.
Please note: this example does not attempt to handle threading and all exceptions.
It gives a simplified overview of the essential gRPC calls.
For a complete android example, see the examples directory in the sdk-cubic github repository.
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;
import com.google.protobuf.ByteString;
import com.cobaltspeech.cubic.CubicGrpc;
import com.cobaltspeech.cubic.CubicOuterClass.*;
public static void streamMicrophoneAudio() {
// Setup connection
CubicGrpc.CubicStub mCubicService = CubicGrpc.newStub(
ManagedChannelBuilder.forTarget(url).build());
// Setup callback to handle results
StreamObserver<> responseObserver = new StreamObserver<RecognitionResponse>() {
@Override
public void onNext(RecognitionResponse value) {
System.out.println("Result: " + value.toString());
}
@Override
public void onError(Throwable t) {
System.err.println("Error with recognition:" + t.toString());
}
@Override
public void onCompleted() {
System.out.println("Server is done sending responses back");
}
};
// Setup bidirectional stream
StreamObserver<StreamingRecognizeRequest> requestObserver; // Outgoing messages are sent on this request object
requestObserver = mCubicService.streamingRecognize(mRecognitionResponseObserver);
// Send config message
RecognitionConfig cfg = RecognitionConfig.newBuilder()
.setModelId("ModelID")
.build();
StreamingRecognizeRequest configs = StreamingRecognizeRequest.newBuilder()
// Note, we do not call setAudio here.
.setConfig(cfg)
.build();
requestObserver.onNext(configs);
// Setup the Android Micorphone Recorder
int SAMPLE_RATE = 8000; // Same as the model is expecting
int BUFFER_SIZE = 1024;
AudioRecord recorder = new AudioRecord(
MediaRecorder.AudioSource.MIC,
SAMPLE_RATE,
AudioFormat.CHANNEL_IN_MONO,
AudioFormat.ENCODING_PCM_16BIT,
BUFFER_SIZE);
byte[] audioBuffer = new byte[BUFFER_SIZE];
recorder.startRecording();
// Read the file in chunks and stream to server.
while (running) {
recorder.read(audioBuffer, 0, BUFFER_SIZE, AudioRecord.READ_BLOCKING);
// Convert byte[] to ByteString for gRPC
ByteString audioBS = ByteString.copyFrom(audioBuffer);
// Send audio to server
RecognitionAudio audioMsg = RecognitionAudio.newBuilder()
.setData(audioBS)
.build();
requestObserver.onNext(StreamingRecognizeRequest.newBuilder()
.setAudio(audioMsg)
.build());
}
// Stop the microphone recoding.
recorder.stop();
// Close the client side stream
requestObserver.onCompleted();
// Note: Once the server is done transcribing everything, it will call responseObserver.onCompleted().
}
This example uses methods of the Client class to establish connection to Cubic server, list models, stream audio file and receive the transcription results. You can call Client from your client view controller or any other class.
import Cubic
import GRPC
class CubicExample {
let client = Client(host: "demo-cubic.cobaltspeech.com", port: 2727, useTLS: true)
var confg = Cobaltspeech_Cubic_RecognitionConfig()
let fileName = "test.wav"
let chunkSize = 8192
public init() {
let fileUrl = URL(fileURLWithPath: fileName)
guard let audioData = try? Data(contentsOf: fileUrl) else { return }
config.audioEncoding = .wav
client.listModels(success: { (models) in
if let model = models?.first {
self.config.modelID = model.id
self.client.streamingRecognize(audioData: audioData, chunkSize: self.chunkSize, config: self.config, success: { (response) in
for result in response.results {
if !result.isPartial, let alternative = result.alternatives.first {
print(alternative.transcript)
}
}
}) { (error) in
print(error.localizedDescription)
}
}
}) { (error) in
print(error.localizedDescription)
}
}
}