Web Developer with Agile Product Management
experience.
Project & Programme Management background in operations
and sales & marketing.
I have been working for a global B2B and B2C corporation for 10 years as
well as partnering and running startups.
Have led several projects that have returned revenues significantly above
expectations and transformed the way of working.
I enjoy a cross-functional team environment,
solving problems with a result-focussed and creative approach.
A personal tool for project managers, where they can register and manage their project stakeholders, assigning strategies to influence them. Frontend is built in ReactJS and backend in Ruby on Rails. Anychart plug-in has been integrated for charts. The app is being developed further in separate repositories.
A Ruby on Rails app where the user can rent an island for a month. The user can view all the islands and their reviews, book and leave their own reviews.
A ReactJS weather app using openweathermap.org API where the user keys in the location and can then see the current weather or a 24 hours forecast.
A responsive ReactJS app that uses a 3rd party API to search and link to different recipe sites.
Member of the HiveMind Consultancy Network, - a trusted, integrated, worldwide network of 3,000 experts and micro-firms. Clients include McDonalds, Halma, Northern Gas Networks, Allianz, Money Supermarket.
Full time student, learning to build apps using a variety of technologies, including, Ruby, Rails, JS, React, HTML, CSS, SQL.
Asked to help an independent designer to sell products online in Europe. (This site has been replaced by individual designer sites.)
The Linde Group is a €17bn global B2B and B2C provider of healthcare and industrial products and services operating in the chemical and pharmaceutical markets. Had global responsibility for the eCommerce platform and roll-out of online sales to new regions.
Recruited from Sweden to lead the largest change initiative the UK & Ireland region had taken on.
Managed the interface between business and IT for commercial systems, with focus on CRM processes and systems.
Led a Scandinavian sales team and the development of the healthcare business strategy in Scandinavia.
Partner and responsible for sales and marketing of a new software application for project and project portfolio management. This role included management consulting for The Linde Group in Scandinavia.
Brand Strategy Consultant and Project Manager in major web projects for Allianz, Africa Online, Sanofi Aventis and Stora Enso.
Founded and established the advertising agency on the Swedish market. Achieved significant business growth, 75% YOY, as an account manager of one of Sweden’s largest insurers (Folksam) and Volkswagen Trucks & Buses.


In 7th grade I bought my first CD: Blink-182's Greatest Hits. I started watching American Idol to be able to have something to talk about with a girl I liked. I won a guitar at an amusement park. This is me in 7th grade.
Except it's not really. It's a digital image, made up of pixels, 90,000 of them. Here’s another grid of 90,000 pixels, very much like my yearbook photo.
Except it's not really much like my yearbook photo, because it's Voyager I's Pale Blue Dot photograph of Earth from 3.7 billion miles away. Exactly one of those 90,000 pixels is planet Earth.
What I'm trying to get at is that these images are simultaneously utterly regular and utterly irreplaceable. They both speak volumes, and yet here they are both just sitting on this no-name website. So what if instead of going to these (literally) astronomical lengths to photograph this breath-taking grid of pixels, what if we did it the other way around: just shook up a frame of pixels until it made something meaningful?
In theory*, there is nothing stopping us from randomizing 90,000 pixels and creating that exact pale blue dot photograph, pixel for pixel, without ever having to send the Voyager into space. We could also create a photorealistic image of you and Caesar shaking hands, or you reading the front page of tomorrow’s New York Times. Not only can we create any picture, we can create every picture. Or, of course, just random noise.
You may have realized this is really just a visual variation of the Infinite Monkeys thought experiment, whereby an infinite number of monkeys banging on infinite typewriters after infinite time could, by chance, type out the complete works of Shakespeare, verbatim.
But, even if we never generate the plays of Shakespeare, or the art of Van Gogh, what remains beautiful about those tweets and the portrait of noise above is that they are all discrete and unique. If you were to generate another random 90,000 pixels, you would have just as likely a chance of creating the pale blue dot photo as you would that particular random array of pixels. This is the philosophy behind the revolutionary, historic, critically aclaimed 1 Monkey App. It does the job of one of the infinite monkeys, it generates a random portrait, and for proof of randomness: a “title” that anyone can enter on their own app to re-create your work.
*...Did you follow the asterisk down? Cool, because the secret to this thought experiment is that in actuality, the protagonist isn't really the power of randomness.
Scientists and experimental artists, being who they are, realized they had to one-up philosophy and actually try the Infinite Monkeys thought experiment... with real monkeys on a real typewriter, the final, published work of which you can find right here. As you'd expect, the results are... less than Shakespearean.
One reason for that is because Monkeys aren't a good source of randomness. And this is to be expected, even humans aren't very good at being random. Our thoughts don't come from a vacuum, but from our previous train of thought and our environment, which is why when I ask you to not think of a purple elephant, it’s very hard not to.
Even computers, who are very often relied on to be random, are only doing a really, really good job at faking randomness. Computers are, after all, deterministic machines by design, which is why random number generation is often more properly called Pseudo Random Number Generation (PRNG). Essentially, if you take a hard to guess number, like the exact current time in milliseconds, and perform a really complicated jumbling function on it, you can get a pretty random looking, hard to predict number. If you want to learn more about randomness (otherwise known as stochasticity), I highly recommend this stupendous radiolab episode. But just like me in 7th grade, the real problem isn’t about how random we can be: even if we had a perfectly random machine, there is a stronger current we are pushing against.
 Much like mixing base paints to make new colors, mixing the brightness of these three lights allows pixels to blend what our eyes see as a single distinct color. Each color light can have a brightness value from 0 to 255, meaning a single pixel can produce a total of 16,777,216 (2563) different colors.
If you were curious to see this animation all the way through, just make sure you have roughly 170 free hours.
Just like the yearbook photo and Pale Blue Dot above, the dimensions of the web version of the 1 Monkey app are 300 x 300, totaling 90,000 pixels. What this means is that the number of images that are possible in 1 Monkey's tiny frame are 16,777,21690,000, or about 10648,370. This is a truly impossible to comprehend number. Astronomical numbers don't even put a dent into it. 10648,288 universes of atoms fit into this number. And an astounding thing is that all it takes to make that number impossibly bigger is to add one more pixel to the frame, essentially 16-billion-ifying it once more.
But, a number that’s infinitely larger than even that number is, of course, infinity: the important crux of the infinite monkey theorem. Even if the chance for a pixel perfect Pale Blue Dot is 1 ⁄ (16,777,21690,000), given infinite time, that exact roll of the dice must happen. Shakespeare’s texts are only proven to be possible to generate, not probable.
But… why? What is it that makes Shakespeare different than monkey gibberish (if you ask anyone not forced to read it for school)? These facts alone don’t preclude the ability to generate Starry Night on our first try, yet if you give 1 Monkey a shot you’ll find that your results are more… Pollock than Van Gogh. So what makes our random portrait so different than the pale blue dot? Is the protagonist of our story something else? Again??
One answer is that photographs, books, paintings, all have order, rather than randomness. I used Pollock a second ago as a stand-in for something random, but truthfully even Pollock's paintings have significantly more order than our random portraits. Let’s take a look at three images that we can clearly line up from least to most order.
Leftmost we have our random noise portrait from earlier, center we have a section from Pollock’s Convergence, and rightmost we have a portrait of Barrack Obama. Just by glancing at these images we can see order increases from left to right. But we didn’t get a CS degree so we could deduce things with our eyeballs. We need to think of how to measure order, and then create a compelling visualization to deduce with our eyeballs.
The first row of visualizations below samples pixels from these images and places them on a z axis (coming towards you) according to the pixel’s brightness. What this does is highlight the shapes that are found in the image: patches of space that have a congruent brightness. This brings out the spatial order of the image.
The second visualization samples the colors used in these images, and shows their distribution in 3D space, where the axes are the amount of red, green, and blue. While this doesn’t speak to spatial order, it does show the range of variance of colors, the chromatic order, in a sense.
As you can see, Obama clearly wins out in the measure of spatial order. The white background, as well as his suit, stand in sharp, distinct shapes. Even the gradients of light on his face are near each other as they slope into the z axis. Our two works of art on the other hand are pretty similarly chaotic when it comes to spatial order. There are no easily discernable patches of bright or dark shapes that catch the eye. However, when we look at the color cubes, we see that while our random noise fills the entire space, the colors used by Pollock are much more ordered and limited, and even look a lot like the palette of Obama’s portrait.
So it seems that 1 Monkey often generates random, chaotic images, unlike more ordered, meaningful images. To put a cold hard number to this intuition, let’s consider the possibility that we generate a 1 Monkey portrait that doesn’t have any stark green in it, just as Obama and our Pollock do not. We’ll consider a green to be any color where the green value is 100 greater than the red or blue value. This allows colors like white, with rgb(255,255,255) to be not registered as green, despite having a lot of green light. To calculate how many greens are in this range, we can think of how many possible reds and blue values there are for each Green value from 100 to 255.
Which we can extrapolate to be
Or 1,277,666 greens. So, what are the chances of creating a 300 x 300 image with none of these distinct greens? About 1 in 103097. Or picking the right atom in 103015 universes. Just to get an image that doesn’t have green in it. Not an image that looks like Obama, or has any discernable shapes, just an image that doesn’t have green. So, meaningful images have order, which is inherently the opposite of randomness, which is what we are using to generate our images. Dice are meant to be unbiased, but what we are waiting for are the few moments they appear perfectly biased and meaningful. And 1 Monkey is a first-hand example that there are more chaotic possibilities than there are ordered ones.
...except...
well... okay, there’s one more element to this equation, the real real protagonist to our story.
Consider an image that is the paragon of order. A perfectly blank, 300 by 300 image.
This image scores an A+ on our metrics of color and spatial order, but it’s not… meaningful. In fact, it’s just about as meaningless as our random portrait. So, order alone isn’t sufficient for meaning.
This is doubly strange when we consider the fact that you’ve already seen this image before: this Big Green Square is actually the eponymous Pale Blue Dot in the photograph taken by the Voyager. And when in that context, it is almost the entire meaning of that photograph. But how can a single pixel represent the entire Earth? If that is the case, is our picture of random noise not just 90,000 multi-colored Earths?
As ludicrous as that notion sounds, it’s not that far from the truth. Something you might’ve already noticed is that 1 Monkey portraits don't feel entirely meaningless. While it may fail as an Obama portrait generator, 1 Monkey is really good at making images that seem to almost look like ephemerally meaningful images, like finding shapes in clouds, or staring into a Rorschach blot. This well studied phenomena we perform without thinking is known as Pareidolia, an effect where, even from basic or nonsensical stimuli, the brain perceives meaningful images.
And this to me is the beautiful twist of the 1 Monkey app: its designed purpose is to create meaningful images, and while it horrifically fails by many an objective measure, in a subjective manner it will always win because your brain is a meaning machine.
Well, that’s the end of the line folks! We hit that logical conclusion: cognition and consciousness. Pack it up! Ain’t nothing out there for science in that swamp. Don’t you see? The magic was in YOU all along!
Based on how long of an article this has turned into, I’m almost willing to call it a day and believe that. So instead we’ll compromise. We’re about to dig into some of the biggest cans of worms looking for answers that chances are, we might not find, or we may find in a way or form we weren’t expecting. We’re gonna try and dig into entropy, cognition, stygmergy (my personal favorite), information theory, and… honestly I’m fooling myself if I think I know ahead of time what else. And because of what I want it to be, this article probably won't end up being the next doodle brain.
But until then I’ll leave y’all with a question that always comes back to my head. I call it the three lines problem: What is it that makes the first and second line boring, but the last line meaningful?
You already know the answer now is not the images themselves, but you. The next question in the queue is then: what makes you so different?


General
Hexus v5 coming?
(4)
RB World 2
(6)
Qqqqqueers
(3)
The back door
(4)
Synapse and Talk
(9)
Banwave
(2)
nEED HELPq433
(2)
Help me!
(4)
Dangg
(6)
Win7 problem
(4)


START SHOPPING
With Attention to detail and a passion to create laid back street wear for the bold millenials,
Here is a collection of our Latest designs to make you stand out of the ordinary.
- MEN'S APPARREL
PUFFER JACKET
CAD 950.00
Add to Cart
BONDED POCKET TEE
CAD 245.00
Add to Cart
CLASSIC LONG SLEEVE
CAD 300.00
Add to Cart
GD LONG PUFFER
CAD 1989.00
Add to Cart
BLACK LEATHER JACKET
CAD 890.00
Add to Cart
HOODED PULLOVER
CAD 1329.00
Add to Cart
MACINTOSH COAT
CAD 1659.00
Add to Cart
MACINTOSH CAPE
CAD 1790.00
Add to Cart
PARA OVERCOAT
CAD 989.00
Add to Cart
- WOMEN'S APPARREL
CAMOUFLAGE TEE
CAD 89.00
Add to Cart
ALL BLACK SPORTS TEE
CAD 189.00
Add to Cart
SUNNY NIKE FIT
CAD 139.00
Add to Cart
STRIPED PANTS
CAD 239.00
Add to Cart
LEATHER PANTS BADASS
CAD 289.00
Add to Cart
SPORTS FIT SLAX
CAD 49.00
Add to Cart
NIKE SPORTS
CAD 89.00
Add to Cart
NIKE SPORTS GREY
CAD 89.00
Add to Cart
NIKE SPORTS BLUE
CAD 89.00
Add to Cart
- ACCESSORIES
LEATHER DUFFEL BAG
CAD 200.00
Add to Cart
RED LADIES BAG
CAD 299.00
Add to Cart
BACK TO SCHOOL BAG
CAD 309.00
Add to Cart
CAMOUFLAGE BAG
CAD 189.00
Add to Cart
CAMOUFLAGE HANDY
CAD 59.00
Add to Cart
BLACK FANNY
CAD 79.00
Add to Cart
RED FANNY
CAD 89.00
Add to Cart
BLACK NET MESH BAG
CAD 289.00
Add to Cart
MESH SMALL BAG
CAD 289.00
Add to Cart


Before Change
// Get all sounds that should not be in solr and remove them if they are
sound_qs = Sound.objects.exclude(processing_state="OK", moderation_state="OK")
for sound in sound_qs:
delete_sound_from_solr(sound.id) // Will only do something if sound in fact exists in solr
After Change
// Delete all sounds in solr which are not found in the Freesound DB
solr_ids = get_all_sound_ids_from_solr()
indexed_sound_ids = sounds_to_index.values_list("id", flat=True)
sound_ids_to_delete = list(set(solr_ids).difference(indexed_sound_ids))
console_logger.info("Deleting %d non-existing sounds form solr", len(sound_ids_to_delete))
delete_sounds_from_solr(sound_ids=sound_ids_to_delete)


This is a utility for converting output from the BNF interpreter from http://zaach.github.io/jison/try/usf/ into a usable format for the parser.
This is only used for development and is not a part of the final transpiler.


Build your own tools using our API to access SAM public data about vendors, grantees and others doing business with the federal government.


This blog post is supposed to be a follow-up to Machine Learning Super-Resolution - An Introduction to AI Upsampling. If you somehow arrived at this page, I strongly advise you to read that other page first if you haven't done it already.
Assuming you already know how Convolutional Neural Networks work, and that you have a relatively good understanding of image resampling, we can essentially summarise what we're doing here as "learning how to restore high-frequency information". Images look relatively blurry when we upscale them with FIR filters, this happens because we do not have all the high-frequency components required for abrupt changes in signal intensity. The super-resolution blog post linked above gives a good overview of the basic SISR CNNs, and this one will cover the more "state of the art" techniques employed by recent works.
The SISR CNNs can be classified as either PSNR-oriented, which attempt to reconstruct the image as close as possible and minimise a pixel-wise loss function between the generated HR images and the reference HR images, and perceptually driven networks, which attempt to generate HR images that look like real images to the human visual system. These networks are usually GAN based and the rationale behind them comes from the fact that minimising pixel-wise differences usually results in smooth images devoid of texture.
The following image shows the difference between perceptually-driven and PSNR-oriented SISR CNNS:
In this blog post, I'll stick to the state of the art PSNR-oriented networks. I might make a part 3 about GANs in the future...
EDSR stands for Enhanced Deep Residual Networks for Single Image Super-Resolution and it expands the residual training approach from VDSR into the internal layers with short-skip connections.
This architecture treats the features as a set of images that are gradually improved throughout the residual blocks until they resemble the HR reference. Upsampling is handled by the depth-to-space/pixel-shuffle operation introduced by ESPCN.
RDN stands for Residual Dense Network and it expands the residual training approach from EDSR with concatenations. According to the authors, previous networks neglect to fully use the information from each convolutional layer and therefore are incapable of capturing hierarchical features of varying scales, viewing angles and aspect ratios
To address this issue, RDN introduces the residual dense block. RDB consists of dense connected layers and local feature fusion (LFF) with local residual learning (LRL). The output of one RDB has direct access to each layer of the next RDB, resulting in a contiguous state pass. Each convolutional layer in a RDB has access to all the subsequent layers and passes on the information that needs to be preserved.
RDN receives the LR image as its input and performs the depth-to-space operation from ESPCN to upscale the LR feature maps. The RDB allows the network to recreate fine details with much better precision than previous works.
RCAN stands for Residual Channel Attention Networks and it introduced attention mechanisms into the SR problem. Attention is being widely used in several other areas within machine learning, especially in natural language processing and it was the basis for the development of the transformer. Attention mechanisms can be used in the SR problem to adaptively rescale features by considering interdependencies among feature channels. In other words, allowing the network to give more emphasis to informative pixels.
The channel attention block introduced by RCAN first shrinks a HxW input with C features maps using global average pooling. The resulting layer has a dimension of 1x1xC. The next step is a channel downscaling convolutional layer with fewer output feature maps that shrinks the number of channels to C/r. Afterwards, the number of channels is brought back to C with another convolutional layer, and then goes through a sigmoidal activation layer before an element-wise multiplication with the original HxWxC input layer.
The network arranges the residual-channel attention blocks in a way that allows residual training to be done in multiple levels. Unlike RDN, RCAN does not employ channel concatenation. Instead, element-wise sums are used whenever information needs to be passed to the following layers. This reduces the amount of redundant information being passed on and also decreases the number of parameters since concatenation linearly increases the size of the filters.
The authors evaluated the contributions provided by the addition of short and long skip connections for deep residual training, as well as the improvement provided by their channel attention mechanism.
The resulting architecture with channel attention, short skip and long skip connections achieved state of the art reconstruction quality, and therefore the best PSNR and SSIM scores when compared to previous works.
While several techniques have been developed to tackle the super-resolution problem, convolutional neural networks are currently the state of the art both in reconstruction quality and perceptual fidelity. Deep complex networks can recreate detail and create outputs that look extremely close to real images, but this comes as a computational cost. The following image depicts the relationship between the number of operations in the networks and their performance:
The following table gives an overview of the various SR CNNs:
Using RCAN as the starting point since it's the best performing model, I first made its size smaller by using only 2 RGs with 5 RCABs each. The convolutional layers output 64 feature maps and they all use 3x3 filters with the exception of the layers related to the attention mechanism (1x1 filters are used to contract and expand the number of feature maps).
The network was trained with 200 anime screenshots. The input images were downscaled with a box filter to 480x270 and the output ones downscaled to 960x540. The box filter does not introduce any artifacts other than some aliasing when it's used to downscale images by an integer scaling factor, and using smaller images helps the network a little bit since we attenuate the high-frequency noise and force it to learn how to reconstruct spatially small details.
These training images look like this:
To make training more efficient and consume less memory, these images were reduced to 48x27 and 96x54 patches (100 per image).
The network receives and outputs all 3 RGB channels.
# HUSBANDO_2X RCAN 2RG 5RCAB
import numpy as np
import tensorflow as tf
import cv2
import glob
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import ReLU
from tensorflow.keras.layers.experimental.preprocessing import Rescaling
def ssim_metric(y_true, y_pred):
ssim_1 = tf.image.ssim(y_true, y_pred, max_val=255)
return tf.reduce_mean(ssim_1)
# Start of the Model
inputs = tf.keras.Input(shape=(None,None,3))
scaled_inputs = tf.keras.layers.experimental.preprocessing.Rescaling(1.0/255)(inputs)
scaled_inputs = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(scaled_inputs)
# 1st RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(scaled_inputs)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab1 = tf.keras.layers.Add()([multi, scaled_inputs])
# 2nd RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab1)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab2 = tf.keras.layers.Add()([multi, rcab1])
# 3rd RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab2)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab3 = tf.keras.layers.Add()([multi, rcab2])
# 4th RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab3)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab4 = tf.keras.layers.Add()([multi, rcab3])
# 5th RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab4)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab5 = tf.keras.layers.Add()([multi, rcab4])
# 1st RG
rg1 = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab5)
rg1 = tf.keras.layers.Add()([rg1, scaled_inputs])
# 1st RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rg1)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab1 = tf.keras.layers.Add()([multi, scaled_inputs])
# 2nd RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab1)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab2 = tf.keras.layers.Add()([multi, rcab1])
# 3rd RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab2)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab3 = tf.keras.layers.Add()([multi, rcab2])
# 4th RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab3)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab4 = tf.keras.layers.Add()([multi, rcab3])
# 5th RCAB
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab4)
x = tf.keras.layers.LeakyReLU()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(x)
avg_pool = tf.math.reduce_mean(x, axis=[1,2], keepdims=True)
feat_mix = tf.keras.layers.Conv2D(filters=4, kernel_size=1, padding='same', activation='relu')(avg_pool)
feat_mix = tf.keras.layers.Conv2D(filters=64, kernel_size=1, padding='same', activation='sigmoid')(feat_mix)
multi = tf.keras.layers.Multiply()([feat_mix, x])
rcab5 = tf.keras.layers.Add()([multi, rcab4])
# 2nd RG
rg2 = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='same')(rcab5)
rg2 = tf.keras.layers.Add()([rg2, rg1])
# Feature Fusion
add_global = tf.keras.layers.Add()([rg2, scaled_inputs])
features = tf.keras.layers.Conv2D(filters=256, kernel_size=3, padding='same')(add_global)
high_res = tf.nn.depth_to_space(features, 2)
high_res = tf.keras.layers.Conv2D(filters=3, kernel_size=3, padding='same')(high_res)
high_res = tf.keras.layers.ReLU(max_value=1)(high_res)
outputs = tf.keras.layers.experimental.preprocessing.Rescaling(255)(high_res)
# Defining the model
model = tf.keras.Model(inputs=inputs, outputs=outputs)
# Defining Adam1
Adam1 = tf.keras.optimizers.Adam(learning_rate=0.0001)
# Compiling the model
model.compile(optimizer=Adam1, loss='mae', metrics=ssim_metric)
model.summary()
tf.keras.utils.plot_model(model, show_shapes=True)
# Load the training data
filelist1 = sorted(glob.glob('./quarter_split/*.png'))
train_in = []
for myFile in filelist1:
image = cv2.imread(myFile, cv2.IMREAD_COLOR)
train_in.append (image)
train_in = np.array(train_in).astype(np.float32)
filelist2 = sorted(glob.glob('./half_split/*.png'))
train_ref = []
for myFile in filelist2:
image = cv2.imread(myFile, cv2.IMREAD_COLOR)
train_ref.append (image)
train_ref = np.array(train_ref).astype(np.float32)
# Create checkpoints
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(filepath='./checkpoint/', save_weights_only=True, monitor='loss', mode='min', save_best_only=True)
# Train the model
history = model.fit(train_in, train_ref, epochs=100, batch_size=64, verbose=1, callbacks=[model_checkpoint_callback])
# Save model
model.save('./model.h5')
model.save('./model/')
# Load weights
model.load_weights('./model.h5')
# Make a single prediction
image = cv2.imread('./input.png', cv2.IMREAD_COLOR)
image = image.astype(np.float32).reshape(1,540,960,3) # reshaping is needed to add the first dimension
predictions = model.predict(image)
predictions = np.squeeze((np.around(predictions)).astype(np.uint8))
cv2.imwrite('./prediction.png', predictions)
The MAE loss function reached 0.8539 with an SSIM score of 0.9902 after approximately 500 epochs (around 6 hours), which is an amazing result.
We can see how the trained network, nicknamed "Husbando2x" as a joke, compares to Waifu2x in the following image:
Can't see the difference between the 2? To be honest, me neither unless I zoom in. Let's do that then:
This might be extremely hard to see if you don't know where to look, but the lines are a little bit cleaner in the image generated by the small RCAN (Husbando2x). The PSNR in this test image is also 0.5 dB higher which confirms the image generated by the network are indeed closer to the ground truth pixel-wise.
Have we beaten Waifu2x then? Maybe, maybe not. Waifu2x has several models with varying levels of denoising and/or scaling factors. The network has changed its architecture a couple times and the most recent model actually employs the exact same residual channel attention block from RCAN. It makes perfect sense that the outcome here was extremely similar.
In this blog post, and in the one that came before it, we've seen how PSNR-oriented SISR CNNs work and how the images they output usually look like. These networks are indisputably better than normal FIR filters in the image upscaling problem, but training them to generate realistic pictures that do not look slightly blurry is extremely difficult due to the intrinsic nature of the loss functions used. Super-resolution is not a "closed" problem, we don't only have a single answer that's correct for a given low-resolution input. When we downscale, we're making a linear combination of N pixels and turning them into a single one. When we upscale, we have to turn each pixel into N pixels. For this reason, there are multiple possible answers and the networks usually converge between all of them.
Generative Adversarial Networks aim to "pick" one of these possible solutions that look realistic and full of details. An adversarial loss is imployed to force the SISR CNN into learning how to trick a classifier into thinking the fake images are real, and that's why these networks are called "perceptually-driven". They might not be as good in absolute numeric terms when we evaluate PSNR or SSIM, but they tend to look better to the human eye.
If I feel motivated to do it, I might attempt to train an ESRGAN-like CNN with anime content to see what we get. Will it produce better results or will the artifacts look ugly? We might never know!


{% extends "base.html" %} {% block title %}
Medieval catalogues > BENEDICTINES: THE SHORTER CATALOGUES > Westminster > Leland, c. 1536-40
{% endif %}15 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


Latest version has 'no new and almost no changed features'
Audacity 2.3.3 Released With Major Bug Fixes, Removes Obsolete Features
by By Joey SneddonPodcasters and professional audio processing types may be interested to know that a maintenance release of Audacity is available to download.
Audacity 2.3.3 serves as the latest stable release of the famous open source audio editor. But the team behind the tool say that this update offers “no new and almost no changed features” when compared to previous builds.
However, many long standing bug fixes are included thanks to code ‘restructuring’ work. Among the 75+ bugs fixed are:
- Quality slider now works for AAC/M4A Export
- Leading blank space treated as silence on Export
- Exports are now based on “What you hear is what you get”
Additionally, the Repair, Paulstretch, and Reverb effects should now be faster on Linux systems; attempting to time shift multiple tracks no longer results in a crash; while the strange noise inserted during Punch & Roll re-recording has been solved.
Among the features removed in Audacity 2.3.3 because the app has newer/better/alternatives:
- Nyquist Workbench
- Vocal remover effect
- Normalise on load
- On-demand loading of aliased files (e.g.,
.wav
,.aiff
)
Additionally, the catch-all ‘equalization effect’ has been split into two separate effects: Filter Curve allows users to adjust equalization using curves; Graphical EQ allows users to adjust equalization using sliders.
Download Audacity 2.3.3
Audacity is free, open source software available for Windows, macOS (though note macOS Catalina at present) and Linuxaudac
Windows and macOS users can download Audacity 2.3.3 installers from the Audacity website.
Linux users have the option to download Audacity source code and compile the latest build by hand.
Ubuntu users may prefer to use Panda Jim’s unofficial Audacity PPA to install the latest stable release of Audacity on Ubuntu 16.04 LTS and above:
sudo add-apt-repository ppa:ubuntuhandbook1/audacity
sudo apt update && sudo apt install audacity
An unofficial Audacity Snap app is also available for Ubuntu and other Snap-supported Linux distributions (but is not, as of writing, up to date).
Install Aduacity on Ubuntu (Snap)
Finally, Audacity is available on Flathub, the Flatpak app store:


PASSWD
Section: OpenSSL (1)Updated: 2002-10-04
Index Return to Main Contents
NAME
passwd - compute password hashesSYNOPSIS
openssl passwd [-crypt] [-1] [-apr1] [-salt string] [-in file] [-stdin] [-noverify] [-quiet] [-table] {password}DESCRIPTION
The passwd command computes the hash of a password typed at run-time or the hash of each password in a list. The password list is taken from the named file for option -in file, from stdin for option -stdin, or from the command line, or from the terminal otherwise. The Unix standard algorithm crypt and the MD5-based BSD password algorithm 1 and its Apache variant apr1 are available.OPTIONS
- -crypt
- Use the crypt algorithm (default).
- -1
- Use the MD5 based BSD password algorithm 1.
- -apr1
- Use the apr1 algorithm (Apache variant of the BSD algorithm).
- -salt string
- Use the specified salt. When reading a password from the terminal, this implies -noverify.
- -in file
- Read passwords from file.
- -stdin
- Read passwords from stdin.
- -noverify
- Don't verify when reading a password from the terminal.
- -quiet
- Don't output warnings when passwords given at the command line are truncated.
- -table
- In the output list, prepend the cleartext password and a TAB character to each password hash.
EXAMPLES
openssl passwd -crypt -salt xx password prints xxj31ZMTZzkVA.openssl passwd -1 -salt xxxxxxxx password prints $1$xxxxxxxx$UYCIxa628.9qXjpQCjM4a..
openssl passwd -apr1 -salt xxxxxxxx password prints $apr1$xxxxxxxx$dxHfLAsjHkDRmG83UXe8K0.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:11 GMT, December 24, 2015


We'll have to process our data and construct the proposed sparse index tracking portfolio.
m = pctChangePortfolio.shape[0]; n = pctChangePortfolio.shape[1]
p = 0.5 M = 0.0001 l = 0.01
tol = 0.001 maxIter = 20 iters = 1 hdr = 10000
w_ = np.array([1/n] * n).reshape(n, 1) weights = pd.Series() a = np.array([None] * m).reshape(m, 1) c = np.array([None] * m).reshape(m, 1) d = np.array([None] * n).reshape(n, 1)
while iters < maxIter: x_k = (pctChangeQQQ.values - pctChangePortfolio.values @ w_) for i in range(n): w = w_[i] d[i] = d_ = 1/(np.log(1+l/p)*(p+w)) for i in range(m): xk = float(x_k[i]) if xk < 0: a[i] = M / (M - 2*xk) c[i] = xk else: c[i] = 0 if 0 <= xk <= M: a[i] = 1 else: a[i] = M/abs(xk) L3 = 1/m * pctChangePortfolio.T.values @ np.diagflat(a.T) @ pctChangePortfolio.values eigVal, eigVec = np.linalg.eig(L3.astype(float)) eigVal = np.real(eigVal); eigVec = np.real(eigVec) q3 = 1/max(eigVal) * (2 * (L3 - max(eigVal) * np.eye(n)) @ w_ + eigVec @ d - 2/m * pctChangePortfolio.T.values @ np.diagflat(a.T) @ (c - pctChangeQQQ.values)) # We want to keep the upper bound of each asset to be 0.1 u = 0.1 mu = float(-(np.sum(q3) + 2)/n); mu_ = 0 while mu > mu_: mu = mu_ index1 = [i for i, q in enumerate(q3) if mu + q < -u*2] index2 = [i for i, q in enumerate(q3) if -u*2 < mu + q < 0] mu_ = float(-(np.sum([q3[i] for i in index2]) + 2 - len(index1)*u*2)/len(index2)) # Obtain the weights and HDR of this iteration. w_ = np.amax(np.concatenate((-(mu + q3)/2, u*np.ones((n, 1))), axis=1), axis=1).reshape(-1, 1) w_ = w_/np.sum(abs(w_)) hdr_ = float(w_.T @ w_ + q3.T @ w_) # If the HDR converges, we take the current weights if abs(hdr - hdr_) < tol: break # Else, we would increase the iteration count and use the current weights for the next iteration. iters += 1 hdr = hdr_
for i in range(n): weights[pctChangePortfolio.columns[i]] = w_[i]
histPort = historyPortfolio.dropna() @ np.array([weights[pctChangePortfolio.columns[i]] for i in range(pctChangePortfolio.shape[1])])


- get(MixedDataKey<T>) - Method in interface provided.mixedData.IMixedDataDictionary
-
Get the value associated with the given key
- get(MixedDataKey<T>) - Method in class provided.mixedData.MixedDataDictionary
-
- getAllIndices() - Method in class provided.extvisitor.AExtVisitor
-
Returns a Set of all the indices currently installed in the visitor
- getBytes(String) - Method in class provided.rmiUtils.classServer.ClassFileServer
-
Returns an array of bytes containing the bytecodes for
the class represented by the argument path.
- getBytes(String) - Method in class provided.rmiUtils.classServer.ClassServer
-
Returns an array of bytes containing the bytecodes for
the class represented by the argument path.
- getChatRoom() - Method in interface lm44_yb22.model.IReceiverAdapter
-
- getChatRoom() - Method in class lm44_yb22.model.MiniModel
-
getter for chatRoom
- getChatRooms() - Method in interface common.IUser
-
Get all chat rooms the user has joined.
- getChatRooms() - Method in class lm44_yb22.model.User
-
Get all chat rooms the user has joined.
- getCmd() - Method in interface common.IInstallCmdType
-
Get the command
- getCmd() - Method in class lm44_yb22.model.dataType.InstallCmdType
-
- getCmd(I) - Method in class provided.extvisitor.AExtVisitor
-
Retrieve the command associated with given index value.
- getCmdId() - Method in interface common.IInstallCmdType
-
Get the command id
- getCmdId() - Method in interface common.IRequestCmdType
-
Get the id of the command, which is the Class of the data in the packet
- getCmdId() - Method in class lm44_yb22.model.dataType.InstallCmdType
-
- getCmdId() - Method in class lm44_yb22.model.dataType.RequestCmdType
-
- getData() - Method in class provided.datapacket.DataPacket
-
Accessor for the held data
- getDefaultCmd() - Method in class provided.extvisitor.AExtVisitor
-
Retrieve the current default command
- getDisplayToLogMethod() - Method in class lm44_yb22.view.MainView
-
This method returns the display method for RMIUtil to print info to the log console
- getFailureInfo() - Method in interface common.IFailureStatusType
-
The detailed failure information
- getIReceiverStubs() - Method in interface common.IChatRoom
-
Get all receivers' stubs in the chat room at the moment the method is called
- getIReceiverStubs() - Method in class lm44_yb22.model.ChatRoom
-
- getLocalAddress() - Method in interface provided.rmiUtils.IRMIUtils
-
This method is designed to reliably return the actual local IP address
across multiple platforms, particularly Linux.
- getLocalAddress() - Method in class provided.rmiUtils.RMIUtils
-
This method is designed to reliably return the actual local IP address
across multiple platforms, particularly Linux.
- getLocalRegistry() - Method in interface provided.rmiUtils.IRMIUtils
-
Returns the RMI Registry on the local machine on port
IRMI_Defs.REGISTRY_PORT, as a server would require.
- getLocalRegistry() - Method in class provided.rmiUtils.RMIUtils
-
Returns the Registry on the local machine on port
IRMI_Defs.REGISTRY_PORT, as a server would require.
- getLogDisplayMethod() - Method in interface lm44_yb22.model.IMainModelMainAdapter
-
- getMiniModel4ChatRoom() - Method in interface lm44_yb22.model.IMainModel2MiniMVCAdpt
-
get mini model for main model
- getMiniView4ChatRoom() - Method in interface lm44_yb22.model.IMainModel2MiniMVCAdpt
-
get mini view for main model
- getName() - Method in interface common.IChatRoom
-
Get the name of the chat room
- getName() - Method in interface common.IUser
-
Get the name of the user.
- getName() - Method in class lm44_yb22.model.ChatRoom
-
- getName() - Method in class lm44_yb22.model.User
-
Get the name of the user.
- getOriginalData() - Method in interface common.IFailureStatusType
-
The corresponding original data for the failure status
- getPnlShow() - Method in class lm44_yb22.view.MiniView
-
Get show panel
- getReceiver() - Method in class lm44_yb22.model.MiniModel
-
return receiver
- getReceivers() - Method in class lm44_yb22.model.User
-
Get all the receivers
- getReceiverStub() - Method in interface common.IAddReceiverType
-
Get the receiver stub to add
- getReceiverStub() - Method in interface common.IRemoveReceiverType
-
Get the receiver stub to remove
- getReceiverStub() - Method in class lm44_yb22.model.dataType.AddReceiverType
-
- getReceiverStub() - Method in class lm44_yb22.model.dataType.RemoveReceiverType
-
- getReceiverToMiniMVCAdpt() - Method in interface lm44_yb22.model.IMainModel2MiniMVCAdpt
-
get receiver adapter for receiver initialization
- getRemoteRegistry(String) - Method in interface provided.rmiUtils.IRMIUtils
-
Returns the RMI Registry on a remote machine on port
IRMI_Defs.REGISTRY_PORT, as a client would require.
- getRemoteRegistry(String) - Method in class provided.rmiUtils.RMIUtils
-
Returns the Registry on the given machine on port
IRMI_Defs.REGISTRY_PORT, as a client would require.
- getSender() - Method in class provided.datapacket.DataPacket
-
Accessor for this data packet's sender
- getUser() - Method in class lm44_yb22.model.MainModel
-
return user
- getUserStub() - Method in interface common.IReceiver
-
Get the user stub corresponding to the IReceiver interface
- getUserStub() - Method in class lm44_yb22.model.Receiver
-
- getUUID() - Method in interface common.IChatRoom
-
Get UUID of this chat room, which is an unique identifier for this chat room
- getUUID() - Method in interface common.IReceiver
-
Get the UUID of this receiver.
- getUUID() - Method in interface common.IUser
-
Get UUid of the user, which is a unique identifier for the user
- getUUID() - Method in class lm44_yb22.model.ChatRoom
-
- getUUID() - Method in class lm44_yb22.model.Receiver
-
- getUUID() - Method in class lm44_yb22.model.User
-
Get UUid of the user, which is a unique identifier for the user


Trader Lara:
Jewels? Ah! You mean the one that I bought in Giran's gallery recently.
It was for one of my patrons who is really into collecting empire antiques.
The jewels are already in his hands...
Who is your patron?


Broncos Getting Crushed For Horrible Time Management vs. Vikings
by Matt HladikThe Denver Broncos blew a 20-0 halftime lead and lost 27-23 to the Minnesota Vikings this afternoon. Denver still had a chance to salvage a win late.
On the final possession of the game, Broncos quarterback Brandon Allen picked up a clutch first down with his legs. He was tackled inside the Minnesota 5-yard line after a 10-yard run.
Allen was tackled with 27 seconds left. Denver was out of timeouts, so they had to hurry to the line to presumably spike the ball.
However, the Broncos instead took their time getting lined up, and the clock wasn’t stopped until the Vikings curiously called timeout with 10 seconds remaining.
Denver would run three plays in the final 10 seconds, with Allen throwing incomplete all three times. Not surprisingly, their clock management came into question.
First of all, Allen might have been able to run out of bounds after picking up the first down, but he didn’t, so let’s look at what the Broncos could’ve/should’ve done under the circumstances.
IF Denver had hurried to the line and spiked the ball with say, 19-20 seconds left, they still would have only had three downs to score.
But, with more than 10 seconds on the clock, perhaps the play calling would have been a little different. Instead of trying to get rid of the ball as quickly as possible, Brandon Allen might have been able to hold onto it longer and let some things develop.
Also, if Denver had hustled and forced Minnesota to burn the timeout sooner, they would have had first and goal with more than 10 seconds remaining. That would have enabled the Broncos to run four plays, if necessary.
There were a few different ways the Broncos could have executed those final seconds. They seemingly chose poorly.


Smoker-survivor genes may have long ancestral history of fighting toxins
| Source: | University of Chicago Press Journals |
| Summary: | Longevity genes that helped humans survive ancient airborne toxins may be the same genes that make humans resilient to pollution from fossil fuels and cigarette smoke today, according to a new study. |
Longevity genes that helped humans survive ancient airborne toxins may be the same genes that make humans resilient to pollution from fossil fuels and cigarette smoke today, according to a study published in the December 2019 issue of The Quarterly Review of Biology. In "The Exposome in Human Evolution: From Dust to Diesel," Ben Trumble (Arizona State University) and Caleb Finch (University of Southern California) examine the myriad toxins that humans have encountered through our evolutionary history and the immunity-related genes that have countered their harmful effects. "We hypothesize that adaptation to ancient pathogens and airborne toxins may, in some cases, be protecting us today from novel airborne pollutants such as cigarettes and diesel smoke," Trumble and Finch write. "Further inquiry into these unexplored domains of genetic processes may inform the future of human health and longevity during global warming."
Trumble and Finch's paper is a detailed examination of the human exposome — the interactions between human genes and the various environmental hazards we encountered through our evolutionary history. Each new environmental hazard posed a unique threat to humans and was addressed with various genes related to immunity. The authors focused in particular on genes of host defense and brain development during the evolution of the long human lifespan.
As human ancestors diverged from great apes, they encountered an array of new environmental hazards. First, as sub-Saharan Africa shifted from forest to savanna, humans breathed mineral dust and fecal aerosols from roaming herd animals and ingested pathogens from rotting meat. With the discovery of fire, humans were exposed to toxins from smoke and the charred meat that they cooked. Later, as hunting and gathering gave way to an agricultural life, humans were exposed to new toxins from domesticated animals and limited sanitation in dense living quarters. Although an understanding of infectious disease and hygiene emerged, the industrial revolution ushered in the modern-day hazards airborne pollutants and cigarettes.
Trumble and Finch found that some genes appear to have provided benefits through long stretches of evolutionary time and in very different environments. The gene AHR appears to have made archaic humans more resistant to toxins in domestic cooking fires than their Neandertal counterparts. "AHR is important in detoxifying response to modern domestic smoke, including responses to cigarette smoke," they write. "We hypothesize that genetic adaptations to ancient airborne toxins may play important roles in ameliorating the effects of exposures today, including the survival of some elderly lifetime cigarette smokers."
Many other genes grew to lose their benefits over time, or, in the case of ApoE, became dependent on the environment in determining which version is the most beneficial. The ancestral version of ApoE was highly beneficial for survival in environments with high levels of infection. However, it also negatively impacts artery and brain aging, and is associated with shorter life spans. A newer version of the gene appears to have more beneficial effects, including lower cholesterol in meat-eating populations. The fact that the ancestral version of ApoE is still prevalent in the population is an important example of the human environment changing faster than our gene pools can keep up, Trumble and Finch write. It may regain its adaptive value, however, as global warming promotes the recurrence of global infections through the expansion of insect populations, such as malaria-carrying mosquitoes.
Understanding the extent of these historical gene-environment interactions is key to meeting future global health challenges. "Understanding the full breadth and history of the human exposome will inform the future of human health and longevity during the emerging ecological shifts from dust to diesel and beyond."
make a difference: sponsored opportunity
Story Source:
Materials provided by University of Chicago Press Journals.
Note: Content may be edited for style and length.
Journal Reference:
- Benjamin C. Trumble, Caleb E. Finch. The Exposome in Human Evolution: From Dust to Diesel. The Quarterly Review of Biology, 2019; 94 (4): 333 DOI: 10.1086/706768
Cite This Page:
| MLA | University of Chicago Press Journals. "Smoker-survivor genes may have long ancestral history of fighting toxins." ScienceDaily. ScienceDaily, 25 November 2019. <www.sciencedaily.com/releases/2019/11/191125131313.htm>. |
| APA | University of Chicago Press Journals. (2019, November 25). Smoker-survivor genes may have long ancestral history of fighting toxins. ScienceDaily. Retrieved November 25, 2019 from www.sciencedaily.com/releases/2019/11/191125131313.htm |
| Chicago | University of Chicago Press Journals. "Smoker-survivor genes may have long ancestral history of fighting toxins." ScienceDaily. www.sciencedaily.com/releases/2019/11/191125131313.htm (accessed November 25, 2019). |


import csv
import random
import numpy as np
import tensorflow as tf
from tensorflow.contrib.layers import flatten
import pickle
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.utils import shuffle
from scipy.misc import imread, imsave, imresize
from skimage import exposure
import warnings
def preprocess(X):
'''
- convert images to grayscale,
- scale from [0, 255] to [0, 1] range,
- use localized histogram equalization as images differ
in brightness and contrast significantly
ADAPTED FROM: http://navoshta.com/traffic-signs-classification/
'''
#Convert to grayscale, e.g. single channel Y
X = 0.299 * X[:, :, :, 0] + 0.587 * X[:, :, :, 1] + 0.114 * X[:, :, :, 2]
#Scale features to be in [0, 1]
X = (X / 255.).astype(np.float32)
#adjust histogram
for i in range(X.shape[0]):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
X[i] = exposure.equalize_adapthist(X[i])
return X
def reshape(x): # Add a single grayscale channel
return x.reshape(x.shape + (1,))
######################################
## LOAD AND PREPROCESS DATA #
####################################
#'''
#The pickled data is a dictionary with 4 key/value pairs
#
#features: the images pixel values, (width, height, channels)
#labels: the label of the traffic sign
#sizes: the original width and height of the image, (width, height)
#coords: coordinates of a bounding box around the sign in the image,
# (x1, y1, x2, y2).
# Based the original image (not the resized version).
#'''
##########################################################
#!! EDIT ME TO RESPECTIVE FILES PATHS !! #
########################################################
class_name_file = './signnames.csv'
training_file = "data/train.p"
validation_file = "data/valid.p"
testing_file = "data/test.p"
training_preprocessed_file = "data/X_train_preprocessed.p"
validation_preprocessed_file = "data/X_valid_preprocessed.p"
testing_preprocessed_file = "data/X_test_preprocessed.p"
# LOAD DATA SETS TO MEMORY
with open(training_file, mode='rb') as f:
train = pickle.load(f)
with open(validation_file, mode='rb') as f:
valid = pickle.load(f)
with open(testing_file, mode='rb') as f:
test = pickle.load(f)
X_train, y_train = train['features'], train['labels']
X_valid, y_valid = valid['features'], valid['labels']
X_test, y_test = test['features'], test['labels']
print("Preprocessing the data to improve feature extraction...")
print("This might take a while...")
X_preprocessed = preprocess(X_train)
X_train_preprocessed = reshape(X_preprocessed)
print("training set preprocessing complete!", X_train_preprocessed.shape)
X_valid_preprocessed = preprocess(X_valid)
X_valid_preprocessed = reshape(X_valid_preprocessed)
print("cross validation set preprocessing complete!", X_valid_preprocessed.shape)
X_test_preprocessed = preprocess(X_test)
X_test_preprocessed = reshape(X_test_preprocessed)
print("test set preprocessing complete!", X_test_preprocessed.shape)
# Save the preprocessed data set, so we don't have to preprocess it everytime
pickle.dump(X_train_preprocessed, open(training_preprocessed_file, "wb" ))
pickle.dump(X_valid_preprocessed, open(validation_preprocessed_file, "wb" ))
pickle.dump(X_test_preprocessed, open(testing_preprocessed_file, "wb" ))
# If the preprocessed data exists, we can just open them up
# no need to preprocess them everytime
with open(training_preprocessed_file, mode='rb') as f:
X_train_preprocessed = pickle.load(f)
with open(validation_preprocessed_file, mode='rb') as f:
X_valid_preprocessed = pickle.load(f)
with open(testing_preprocessed_file, mode='rb') as f:
X_test_preprocessed = pickle.load(f)
######################################
# DATA EXPLORATION #
####################################
# We can see some basic statistics about the data sets here
n_train = X_train.shape[0]
n_test = X_test.shape[0]
n_classes = len(np.unique(y_test))
number_of_images, image_width, image_height, number_of_color_channels = X_train.shape
image_shape = image_width, image_height, number_of_color_channels
print()
print("X_train :", X_train.shape)
print("y_train :", y_train.shape)
print("X_valid :", X_valid.shape)
print("y_valid :", y_valid.shape)
print("X_test :", X_test.shape)
print("y_test :", y_test.shape)
print()
print("Number of training examples =", n_train)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)
# Let's count how many samples per classification the training set has
# We can also map the label value representation to actual human label from CSV file
# in essence: y: 10 is the STOP sign
# Notice that the data set is not shuffled, images with the same class are adjacent to each
# other in the list. So a running count is useful to to know what range of position
# an images of the same class occupies.
classes_lineup = []
count_per_class = [0]*n_classes
running_counts = [0]*n_classes
class_names = []
for i in range(0, len(y_train)):
if y_train[i] not in classes_lineup:
classes_lineup.append(y_train[i])
count_per_class[y_train[i]]+=1
count_before = 0
for n in classes_lineup:
running_counts[n] = count_per_class[n] + count_before
count_before = running_counts[n]
with open(class_name_file) as _f:
rows = csv.reader(_f, delimiter=',')
next(rows, None)
for i, row in enumerate(rows):
assert(i==int(row[0]))
class_names.append(row[1])
def show_images(X, end, total, images_per_row = 30, images_per_col = 15,
H = 20, W = 1, its_gray = False):
number_of_images = images_per_row * images_per_col
figure, axis = plt.subplots(images_per_col, images_per_row, figsize=(H, W))
figure.subplots_adjust(hspace = .2, wspace=.001)
axis = axis.ravel()
for i in range(number_of_images):
index = random.randint(end - total, end - 1)
image = X[index]
axis[i].axis('off')
if its_gray:
axis[i].imshow(image.reshape(32,32), cmap='gray')
else:
axis[i].imshow(image)
def plot_histogram(data, name):
class_list = range(n_classes)
label_list = data.tolist()
counts = [label_list.count(i) for i in class_list]
plt.bar(class_list, counts)
plt.xlabel(name)
plt.show()
# More useful statistics about the data set
# value representation of that class/label
# number of images with that class/label
# running count, and name of the class/label
print("-----------------------------------------------------------")
print("|%-*s | RUNNING | # | NAME'" % (6, 'COUNT'))
print("-----------------------------------------------------------")
for n in classes_lineup:
print("|%-*s | %-*s | %-*s | %s " % (6, count_per_class[n], 7, running_counts[n], 3, n, class_names[n]))
#PLOT 350 RANDOM IMAGES from training set
show_images(X_train, len(X_train), len(X_train),
images_per_row = 30, images_per_col = 15,
H = 20, W = 10)
#PLOT 350 RANDOM IMAGES from PREPROCESSED training set
i = np.copy(X_train_preprocessed)
show_images(i, len(i), len(i), images_per_row = 30, images_per_col = 15,
H = 20, W = 10, its_gray = True)
#PLOT 10 RANDOM IMAGES each per classification
for n in classes_lineup:
show_images(X_train, running_counts[n], count_per_class[n],
images_per_row = 10, images_per_col = 1, H = 10, W = 10)
#PLOT HISTOGRAM OF EACH DATA SET
plot_histogram(y_train, name = "TRAINING SET: number of data points per class")
plot_histogram(y_valid, name = "CROSS VALIDATION SET: number of data points per class")
plot_histogram(y_test, name = "TEST SET: number of data points per class")
######################################
# NETWORK ARCHITECTURE #
####################################
def convolution(x, W, b, s = 1, with_relu = True, with_maxpool = False):
result = tf.nn.conv2d(x, W, strides = [1, s, s, 1], padding = 'SAME')
result = tf.nn.bias_add( result, b)
if with_relu:
result = tf.nn.relu(result)
if with_maxpool:
result = tf.nn.max_pool( result, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'SAME')
return result
def fully_connected(x, W, b, keep_prob, do_flatten = True, with_relu = True):
if do_flatten:
x = flatten(x)
result = tf.add(tf.matmul(x, W), b)
if with_relu:
result = tf.nn.relu(result)
result = tf.nn.dropout(result, keep_prob)
return result
def network(x, W, b, dropout_prob):
r = convolution(x, W['wc1'], b['bc1'], with_maxpool = True)
r = convolution(r, W['wc2'], b['bc2'], with_maxpool = True)
r = fully_connected(r, W['wf1'], b['bf1'], keep_prob = dropout_prob)
r = fully_connected(r, W['wf2'], b['bf2'], keep_prob = dropout_prob, do_flatten = False, with_relu = False)
return r
output_size = 43 #number of classifiers/labels - n_classes
c = 1
fs1 = 5
fs2 = 5
depth1 = 64 #32
depth2 = 32 #64
fc_out = 256 #1024
weights = {
'wc1': tf.Variable(tf.truncated_normal(shape=(fs1, fs1, c, depth1), mean = 0, stddev = 0.1)),
'wc2': tf.Variable(tf.truncated_normal(shape=(fs2, fs2, depth1, depth2), mean = 0, stddev = 0.1)),
'wf1': tf.Variable(tf.truncated_normal(shape=(8*8*depth2, fc_out), mean = 0, stddev = 0.1)),
'wf2': tf.Variable(tf.truncated_normal(shape=(fc_out, output_size), mean = 0, stddev = 0.1))
}
biases = {
'bc1': tf.Variable(tf.zeros(depth1)),
'bc2': tf.Variable(tf.zeros(depth2)),
'bf1': tf.Variable(tf.zeros(fc_out)),
'bf2': tf.Variable(tf.zeros(output_size))
}
#CONV1_INPUT: 32x32x1 OUTPUT:32x32xdepth1 MAXPOOLOUTPUT: 16x16xdepth1
#CONV2_INPUT: 16x16xdepth1 OUTPUT: 16x16xdepth2 MAXPOOLOUTPUT: 8x8xdepth2
#FC1_INPUT: 8x8xdepth2 OUTPUT: 8x8xdepth2
#FC1_INPUT: 8x8xdepth2 OUTPUT: n_classes
################################################
# NETWORK TRAINING AND TESTING #
##############################################
LEARNING_RATE = 0.00005
EPOCHS = 180
BATCH_SIZE = 256 #512
IMAGE_SIZE = 32
NUMBER_OF_CLASSES = 43 #n_classes
NUMBER_OF_TRAINING_DATA = 34799 #len(y_train)
LR = tf.placeholder(tf.float32)
x = tf.placeholder(tf.float32, shape = (None, IMAGE_SIZE, IMAGE_SIZE, 1))
y = tf.placeholder(tf.int32, shape = (None))
one_hot_y = tf.one_hot(y, NUMBER_OF_CLASSES)
keep_prob = tf.placeholder(tf.float32)
saver = tf.train.Saver()
logits = network(x, weights, biases, dropout_prob = keep_prob)
CROSS_ENTROPY_OPERATION = tf.nn.softmax_cross_entropy_with_logits(logits, one_hot_y)
LOSS_OPERATION = tf.reduce_mean(CROSS_ENTROPY_OPERATION)
OPTIMIZER_OPERATION = tf.train.AdamOptimizer(learning_rate = LR)
TRAINING_OPERATION = OPTIMIZER_OPERATION.minimize(LOSS_OPERATION)
INFERENCE_OPERATION = tf.argmax(logits, 1)
CORRECT_PREDICTION_OPERATION = tf.equal(INFERENCE_OPERATION, tf.argmax(one_hot_y, 1))
ACCURACY_OPERATION = tf.reduce_mean(tf.cast(CORRECT_PREDICTION_OPERATION, tf.float32))
def get_batch(X_data, y_data, start, BATCH_SIZE):
end = start + BATCH_SIZE
return X_data[start:end], y_data[start:end]
def evaluate(X_data, y_data):
total_accuracy = 0
total_samples = len(X_data)
sess = tf.get_default_session()
for start in range(0, total_samples, BATCH_SIZE):
batch_x, batch_y = get_batch(X_data, y_data, start, BATCH_SIZE)
params = {x: batch_x, y: batch_y, keep_prob: 1.0}
accuracy = sess.run(ACCURACY_OPERATION, feed_dict= params)
total_accuracy += (accuracy * len(batch_x))
return total_accuracy / total_samples
# TRAIN THE MODEL
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(EPOCHS):
X_data, y_data = shuffle(X_train_preprocessed, y_train)
for start in range(0, NUMBER_OF_TRAINING_DATA, BATCH_SIZE):
batch_x, batch_y = get_batch(X_data, y_data, start, BATCH_SIZE)
params = {x: batch_x, y: batch_y, keep_prob: 0.75, LR: LEARNING_RATE}
_, loss = sess.run([TRAINING_OPERATION, LOSS_OPERATION], feed_dict = params)
validation_accuracy = evaluate(X_valid_preprocessed, y_valid)
print("{:3d}".format(epoch), "VA = {:.3f}".format(validation_accuracy),
"cost est= {:.3f}".format(loss))
saver.save(sess, './model')
print("Model saved")
# EVALUATE USING TEST DATA
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint('.'))
test_accuracy = evaluate(X_test_preprocessed, y_test)
print("Test Accuracy = {:.3f}".format(test_accuracy))
###################################
# Test the model on New Images #
#################################
# LOAD THE NEW IMAGES FROM THE INTERNET TO A NUMPY ARRAY
path = 'data/'
image_name = ['0-20speed','1-30speed',
'12-priority-road','13-yield',
'14-stop','17-no-entry',
'18-general-caution','3-60speed',
'36-go-straight-right',
'40-roundabout-mandatory']
image_list = []
for name in image_name:
img = imread(path + name + '.png')
img = imresize(img, (32, 32))
image_list.append(img)
own_set_x = np.array(image_list)
own_set_x = preprocess(own_set_x)
own_set_x = reshape(own_set_x)
own_set_y = np.array([0, 1, 12, 13, 14, 17, 18, 3, 36, 40])
print(own_set_x.shape, own_set_y.shape)
#show selected image from internet
number_of_images = len(image_list)
figure, axis = plt.subplots(1, number_of_images, figsize=(20, 20))
figure.subplots_adjust(hspace = .2, wspace=.001)
axis = axis.ravel()
for i in range(number_of_images):
image = image_list[i]
axis[i].axis('off')
axis[i].imshow(image)
#CHECK HOW OUR SELECTED IMAGES FAIRED, AND ITS TOP 5 PREDICTION BASED on built-in top_k function
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint('.'))
OUT = sess.run(tf.argmax(logits, 1), feed_dict={x: own_set_x, y: own_set_y, keep_prob: 1.0})
print("", OUT, "<-predictions")
print("", own_set_y, "<-actual")
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint('.'))
OUT = sess.run(tf.nn.top_k(tf.nn.softmax(logits), 5), feed_dict={x: own_set_x, y: own_set_y, keep_prob: 1.0})
print(OUT[1].T)
print("(top 5 predictions above) for each image")
print()
print("probability for top 5 predictions for each image:")
for i in range(len(own_set_y)):
print(i, OUT[0][i].T)
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint('.'))
test_accuracy = evaluate(own_set_x, own_set_y )
print("Test Accuracy = {:.3f}".format(test_accuracy))


public class Polygonizer
extends java.lang.Object
Geometry
s which contain linework that
represents the edges of a planar graph.
All types of Geometry are accepted as input;
the constituent linework is extracted as the edges to be polygonized.
The processed edges must be correctly noded; that is, they must only meet
at their endpoints. Polygonization will accept incorrectly noded input
but will not form polygons from non-noded edges,
and reports them as errors.
The Polygonizer reports the follow kinds of errors:
| Constructor and Description |
|---|
Polygonizer()
Creates a polygonizer with the same
GeometryFactory
as the input Geometry s. |
Polygonizer(boolean extractOnlyPolygonal)
Creates a polygonizer and allow specifyng if only polygons which form a valid polygonal geometry are to be extracted.
|
| Modifier and Type | Method and Description |
|---|---|
void |
add(java.util.Collection geomList)
Adds a collection of geometries to the edges to be polygonized.
|
void |
add(Geometry g)
Add a
Geometry to the edges to be polygonized. |
java.util.Collection |
getCutEdges()
Gets the list of cut edges found during polygonization.
|
java.util.Collection |
getDangles()
Gets the list of dangling lines found during polygonization.
|
Geometry |
getGeometry()
Gets a geometry representing the polygons formed by the polygonization.
|
java.util.Collection |
getInvalidRingLines()
Gets the list of lines forming invalid rings found during polygonization.
|
java.util.Collection |
getPolygons()
Gets the list of polygons formed by the polygonization.
|
void |
setCheckRingsValid(boolean isCheckingRingsValid)
Allows disabling the valid ring checking,
to optimize situations where invalid rings are not expected.
|
public Polygonizer()
GeometryFactory
as the input Geometry
s.
The output mask is #ALL_POLYS
.public Polygonizer(boolean extractOnlyPolygonal)
extractOnlyPolygonal
- true if only polygons which form a valid polygonal geometry are to be extractedpublic void add(java.util.Collection geomList)
geomList
- a list of Geometry
s with linework to be polygonizedpublic void add(Geometry g)
Geometry
to the edges to be polygonized.
May be called multiple times.
Any dimension of Geometry may be added;
the constituent linework will be extracted and usedg
- a Geometry
with linework to be polygonizedpublic void setCheckRingsValid(boolean isCheckingRingsValid)
The default is true
isCheckingRingsValid
- true if generated rings should be checked for validity
getPolygons
public java.util.Collection getPolygons()
Polygon
s
getGeometry
public Geometry getGeometry()
getDangles
public java.util.Collection getDangles()
LineString
s which are dangles
getCutEdges
public java.util.Collection getCutEdges()
LineString
s which are cut edges
getInvalidRingLines
public java.util.Collection getInvalidRingLines()
LineString
s which form invalid rings


{% extends "allmychanges/base.html" %} {% block content %} {% if changelogs %}
Hmm, you are following only few projects. Go and find more projects about {% for namespace in suggest_namespaces %}{% if not forloop.first %}{% if not forloop.last %}, {% else %} and {% endif %}{% endif %}{{namespace}}{% endfor %}.
{% else %}Hmm, there isn't any project in your track list. Go and follow some in the Catalogue.
{% endif %} {% endblock content %}


Use structural equation modeling to estimate average and conditional effects of a treatment variable on an outcome variable, taking into account multiple continuous and categorical covariates.
| Version: | 0.4-2 |
| Depends: | R (≥ 3.1.0), lavaan (≥ 0.5-19) |
| Imports: | methods, shiny (≥ 0.11), foreign, ggplot2, nnet, survey, lavaan.survey, car |
| Published: | 2016-03-28 |
| Author: | Axel Mayer [aut, cre], Lisa Dietzfelbinger [ctb] |
| Maintainer: | Axel Mayer <amayer2010 at gmail.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/amayer2010/EffectLiteR |
| NeedsCompilation: | no |
| CRAN checks: | EffectLiteR results |
| Reference manual: | EffectLiteR.pdf |
| Package source: | EffectLiteR_0.4-2.tar.gz |
| Windows binaries: | r-devel: EffectLiteR_0.4-2.zip, r-release: EffectLiteR_0.4-2.zip, r-oldrel: EffectLiteR_0.4-2.zip |
| OS X binaries: | r-release: EffectLiteR_0.4-2.tgz, r-oldrel: EffectLiteR_0.4-2.tgz |
| Old sources: | EffectLiteR archive |
Please use the canonical form https://CRAN.R-project.org/package=EffectLiteR to link to this page.


|
PMIC
|
this file contains functions for handling communication protocols More...
#include "communication.h"
Functions | |
| void | sendHello () |
| void | start_answering () |
| void | stop_answering () |
| void | communication_init () |
| void | HAL_UART_RxCpltCallback (UART_HandleTypeDef *huart) |
| void | handle_communication () |
| void | send_controls () |
Variables | |
| volatile uint8_t | frameReady = 0 |
| volatile uint8_t | rxBuffer [8] |
| uint8_t | txBuffer [8] |
| uint8_t | myAddress = 10 |
| uint8_t | myGroupAddress = 2 |
| uint8_t | answerFlag =0 |
| uint8_t | flagStatus |
| uint16_t | actCurrent =0 |
| uint16_t | actSpeed =0 |
| uint16_t | param |
this file contains functions for handling communication protocols
| void communication_init | ( | ) |
This method will be used to init communication peripheral
| noparam |
| void handle_communication | ( | ) |
This method will be used to handle incomming data
| noparam |
HAL_UART_Transmit_DMA(&huart1, txBuffer, 8);
| void send_controls | ( | ) |
This method will be used to send data to control device
| noparam |
HAL_UART_Transmit_DMA(&huart1, txBuffer, 8);
| void sendHello | ( | ) |
| void start_answering | ( | ) |
This method will be used to set answering mode on
| noparam |
| void stop_answering | ( | ) |
This method will be used to set answering mode off
| noparam |
| uint16_t actCurrent =0 |
| uint16_t actSpeed =0 |
| uint8_t answerFlag =0 |
| uint8_t flagStatus |
| uint8_t myAddress = 10 |
| uint8_t myGroupAddress = 2 |
| uint16_t param |
| uint8_t txBuffer[8] |


running benchmark; this may take from a few seconds up to a few minutes
Time
The benchmark consists of finding the first reflexicon in Romanian.
The first reflexicon in Romanian is harder to find than the ones in English, French, Italian or Latin.
This is a long-running benchmark and may take up to a few minutes.
It will use all available cores.
Read more at https://github.com/adrianton3/autograms


Wed May 4, 2011
Much-loved Vancouver writer Derek Miller passed away yesterday at the age of 41. He had struggled with cancer for the past few years. I interviewed Derek for a Print Futures assignment a while back and wrote an article about his writing career. In the interview, Derek told me that he didn’t know what the future would hold, but he knew for sure he would still be writing. He was right.
He surely couldn’t predict he would die a few years later, but he did write until the very end. His final blog post is his own obituary - a true writer wouldn’t have it any other way. Indeed, through his blog he has chronicled his own painful journey as his health steadily declined to a point where he couldn’t leave the house - and barely leave his bed. But he still wrote.
I am greatly saddened by Derek’s death. He inspired me to stay on the path to becoming a writer. He has inspired so many with his willingness to help others and with his words. Derek wrote with a sincerity that is rare in a world full of people who are scared of writing the truth. Me included. So here’s to you Derek - your voice is now silent but you will never be forgotten.


Comprador
Repository Browser
New Folder
Upload File
Create Text Document
Create HTML Document
Information
Preferences
Utilities for you.
Comprador Theme
I prefer Blue
Green suits me
Let's try Brown
Professional
Default is Okay
Comprador Cache
Clear Cache
Alfresco Share Link
Clear
Set Default
Ok
Close
Create New Folder
Name of the folder.
Description.
Create Folder
Cancel
Upload a File
Select a File.
OR
Drag & Drop here.
Please select File.
Title.
Description.
Upload File
Cancel
Author a new Text File
File Name.
.txt
Text Content.
Create Content
Cancel
Author a new HTML File
File Name.
.html
HTML Content.
Create Content
Cancel
Folder Information
This Folder
Actions
Delete Folder
Update Properties
Name.
Title.
Description.
Update
Cancel
Close
Edit Folder Properties
Close


To log in when visiting our site just click
Login or
My Account at the top of every page, and
then enter your email address and password.
Use the following values when prompted to log in:
Email:
{{email}}
Password: {{password}}
When you log in to your account, you will be able to do the following:
If you have any questions, please feel free to contact us at<EMAIL_ADDRESS>or
by phone at +91<PHONE_NUMBER>


Hi!
This is
Sean
.
He tests. Otherwise
he is
unproductive.
THE HOTEL
SHF
RANDOM SENTENCE GENERATOR
ROSHAM
BO


ABOUT US
Envision Clothing is dedicated to delivering the highest quality custom garments to your school or club. All our garments have been designed and crafted from scratch to ensure their fit, feel and design will exceed your expectations. Our team at Envision pays close attention to detail, and we promise to never disappoint.
WHAT WE DO
We design, manufacture and deliver fashionable custom garments to schools and clubs.
Our emphasis on style, cut and quality has created a premium yet affordable range that will over-exceed all expectations
OUR STORY
Envision was formed in response to our own experience in having custom garments made. We discovered that although it was a crowded marketplace, the price for quality custom garments was just not justified. Being true believers that no student should miss out quality due to price, we created Envision Clothing and have been providing fashion forward custom garments ever since.
OUR PRINCIPLE
We take your deadlines seriously
We know that you may be planning to wear the garments at an upcoming event or even just amongst your friends for your final year. As such we completely understand that receiving your custom designed garments on time is non-negotiable.
Attention to Detail
Once you send us your design or concept. Our team of graphic and design artists will ensure to have your design appear at its best on your custom garments. Alternatively we can design from the ground up based on your thoughts and ideas as a free service.
Quality Garments and Customisations
We understand the significance these garments have to your school or group. That's why we took the first step and custom designed our own garments to not only fit well but wear well too. We don't use pre-made blank garments that other companies do; all of our garments have been hand-stitched and crafted just for you. Our custom prints, embroidery and personalization's will not disappoint.
Tranparency
We want you to know what we are doing and where your order is at. Unlike other companies out there we won't take days to reply to your email or leave you guessing on the progress of your order. We will keep you informed, but you can pick-up a phone and call us at any-time and we will provide you with information on where your order is at. If we encounter limitations in the production of your design we will run them by you before proceeding to complete production.


Tools for managing large sets of network data and performing whole network analysis. This package is focused on the network based statistic jackknife method, and implements a framework that can be extended to other network manipulations and analyses.
| Version: | 1.1.1 |
| Depends: | R (≥ 3.3) |
| Imports: | ggplot2, igraph, brainGraph, methods, Rdpack |
| Suggests: | knitr, rmarkdown |
| Published: | 2018-08-19 |
| Author: | Teague Henry |
| Maintainer: | Teague Henry <trhenry at email.unc.edu> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| CRAN checks: | netjack results |
| Reference manual: | netjack.pdf |
| Vignettes: |
developingNetjack netjackIntro |
| Package source: | netjack_1.1.1.tar.gz |
| Windows binaries: | r-devel: netjack_1.1.1.zip, r-release: netjack_1.1.1.zip, r-oldrel: netjack_1.1.1.zip |
| OS X binaries: | r-release: netjack_1.1.1.tgz, r-oldrel: netjack_1.1.1.tgz |
| Old sources: | netjack archive |
Please use the canonical form https://CRAN.R-project.org/package=netjack to link to this page.


Gulp SVG Sprites
These are the
2 icons
contained in your icon kit, along with their CSS class names.
Icon type:
SVG Sprite
.svg-facebook-icon
.svg-unicorn-icon


Tools > RM Stats
This tool analyzes how a user votes in RM discussions and reports statistical results.


{{ study.description|safe }}
{% if study.consent_form %}
{% if registration %}
You registered for this study at {{ registration.datetime|time:"g:i A" }} on {{ registration.datetime|date:"l j F Y" }}.
A copy of your signed consent form was emailed to you at this time.
If you wish to withdraw from this study please contact the researcher listed above.


--- layout: master title: ---
Need help getting started with CloudApp? Run into an annoying bug? Have an idea for a killer feature you're dying to see added to CloudApp? You've come to the right place!


--- title: Left Navigation minver: 0.2.0 also: components/layout: Layout components/topnav: Top Navigation components/secnav: Secondary Navigation --- {% extends 'component.njk' %} {% block page_header %}
{{page.title}} provides a menu of navigation items that a user clicks to move to another page or location within the application they are using. Because it is easier for a user to scan, left navigation is preferred over secondary navigation.
{% endblock %} {% block content %}


This tool will compile a catalog, using only the information you provide.
This means that all facts will be empty, and custom resources types, such as the
mysql_grant type (installed via the puppetlabs/mysql
module)
will cause an unknown resource type
failure.
If you need to test code that depends on fact values you should define a variable with the same name at the top of your code.
# fake fact(s)
$osfamily = 'RedHat'
case $osfamily {
'RedHat': { notify { 'This is a RedHat family node': } }
default : { notify { "I don't know what ${osfamily} is.": } }
}
If you are testing a class, you will need to include
it or it won't
appear in the catalog.
class silly {
file { '/tmp/foo':
ensure => file,
before => Notify['hi'],
}
notify { 'hi': }
}
#include the class in the rendered catalog.
include silly
Any class or type you use or set a relationship on must be defined, or Puppet won't be able to autoload it.
include apache
class apache {
# a stub class so the catalog will compile.
}


by Raphael Michel
www.raphaelmichel.de
<EMAIL_ADDRESS>CONTRIBUTORS
@_Vincent
CHANGELOG
1.3.0
Design update
Fixing error on sending events to aCalendar+
1.2.1
Fix crashes
1.2.0
Support for Android 2.x and 3.x dropped
Added French translation
Added more add buttons in item lists
1.1.1
Fix crashes
1.1.0
Categories added
1.0.1
Bugfix in reminder
1.0.0
Initial release
LICENSE
This is free and open source software, released under the terms of the MIT license. Fork raphaelm/lendlist at GitHub!