You can also have
only a part
of the dynamic value of
any
symbol inserted.
To do so, before the closing square brackets of the symbol insert the wanted character range (first and last character index, starting at 1, both inclusive)
wrapped in braces in the form of
{first-last}
.
[map{2-10}]
Which in case of
"Cloud Kingdom LE"
results in
"loud King"
.


Telecom company manages millions subscribers and the subscribers generate billions calling and surfing internet records. With the increase of records, finding useful information becomes a challenge.
This project will go to find/lean new pattern from the large volume of data by applying Machine Leaning technology.
Targets include:
- Subscriber fraud detection
- Valuable subscribers finding
- Telecom Services using trend analysis
- Business decision data preparing
Three layer artecher: Leaning engine, Leaning system management & accessing application and User Interface (Explorer, Taplet, iOS, Android) - Learning Engine Features (Spark + Hadoop) - Distributed computing network based - Steam data leaning support - Ongoing update leaning model - Learn status and result stores in NoSQL database - Telecom Customized learning models - Fraud Detection - Individual subscriber’s habit leaning - Over view of service trends for groups - other models which can be extended
Technique for learning engine
Our solution is to use Hadoop as distributed computing framework, use Spark and its machine learning library as leaning learning engine, which runs on Hadoop. - System Management & Accessing Features(JavaEE + Jersey + Tomcat8) - An united Management middleware will be designed to manage - creating new leaning task - checking on going leaning task - querying finished leaning task and returning leaning results - RESTful API will be well designed to make system friendly to kinds of user devices.
Technique for web application
Using tomcat as web application server, using javaEE and Jersey to program RESTful TelecomBI management and accessing application. - User Interface Features (JS (Jquery) + HTML&CSS + Bootstrap) - Using RESTful style accessing API to create user interface on multi-devices such as explorer, iOS, Android.
Technique for client
Using HTML&CSS + Bootstrap to create user interface, Using JS accompanied with JQuery to query data from RESTful API server.
| Technology | Purpose |
|---|---|
| Java Programming | Implement TelecomBI Server. </br> Implement Learning Engine |
| Scala Programming | Implement Learning Engine |
| Jersey | Implement Java RESTful web application |
| Java EE | Implement Java web application |
| Tomcat | Launch Jave Web Application |
| Hadoop | Implement Distributed computing framework |
| Spark | Implement Stream Data processing |
| Machine Leaning | Implement TelecomBI core learning Engin Algorithms |
| HTML&CSS | Implement user interface |
| Bootstrap | Improve user interface and simplify UI development |
| JS (JQuery) | Implement data query from web servers by RESTful API |
| Maven | Help to manage Java projects (Three projects) |
| Github | Help to manage code and team development |
| Project | version |
|---|---|
| Spark | 1.4 |
| Hadoop | 2.6 |
| Jersey | 2.19 |
| Tomcat | 8.0 |
| Java | 8.0 |
| Scala | 2.11.7 |
| Bootstrap | 3.3.5 |
| JQuery | 2.1.4 |
| HTML&CSS | 5 |
| Maven | 3.3.3 |
| Eclipse | 4.5 |


Money Play. Should Red double? If doubled, should White take?
pips Red=150 White=155
(CorrectAnswer= 0/0, ErrorScore= 0)
This is an excellent reference position.
It should be clear that red should double. He has the stronger position and a number of threats. He is even marginally ahead in the race. Not doubling this would be a bad blunder.
The take/drop decision is right on the borderline with XG rating either action as correct. White has an anchor and all his checkers in play, albeit some of them in ugly stacks. The optimist takes, the pessimist passes.
It should be clear that red should double. He has the stronger position and a number of threats. He is even marginally ahead in the race. Not doubling this would be a bad blunder.
The take/drop decision is right on the borderline with XG rating either action as correct. White has an anchor and all his checkers in play, albeit some of them in ugly stacks. The optimist takes, the pessimist passes.
Cube analysis 2-ply cubeless equity +0.585 0.704 0.236 0.017 - 0.296 0.072 0.003 Cubeful equities: 1. Double, take +0.969 2. Double, pass +1.000 (+0.031) 3. No double +0.845 (-0.124) Proper cube action: Double, take


Instructor: Kostas Tsakalis, GWC 358, 965-1467, (This page: http://www.fulton.asu.edu/~tsakalis)
Office Hours: T W Th
1:00-2:00 or by appt.
Textbook: A. Rodriguez, Feedback control.
Other references: Franklin,
Powell, Emami-Naeini Feedback Control of Dynamic Systems, 3rd
Ed., Addison Wesley, 1994.
Grading:
480: Final 35, HW 5, Exams {best 4
out of 5}*10, Lab 20
591: Final 40, HW 10, Exams 5*10
Typically: A > 85 > B > 75 > C > 60 >
...

 See dates below.
Final Exam: Fri. May 7, 10:00-11:50
1. Lab Experiments (.pdf)
2a. Sample report for Lab1 (short
version) (.doc)
2b. Lab 1
report details (.doc)
3. Sample
simulink models and Matlab scripts for the lab (.zip)
HW Assignments, Test Material, Handouts
HW Problem Statements and the relevant figures
Reading material:
Introduction: performance-robustness (.ppt;
why, what and a little how...)
Examples of System Models and theirSimulink implementation
(#1: .pdf, #2 .zip compressed mdl files etc.)
Notes on model approximations and loop-shaping
(.pdf)
Lead-Lag Controller Design review
(.pdf)
Case studies and their sim-files
Quick PID Tuner (.zip of several
m-files)


Experienced Retail Brand Marketing Executive with over 10 years of rich and varied experience, building and executing retail environments that meet the go-to market strategies of some of the worlds best brands. Creating an authentic, engaging and compelling brand experience in 3-D spaces with the aim to increase sell-through and build brand awareness. Manage both seasonal and long-term strategic approaches that implement omni-channel marketing for the retail environment. Known for professionalism, vision, integrity, innovation and continuous growth. In-depth knowledge of progressive retail business models and go-to-market processes. Equally strong in negotiating and managing vendor relationships for accurate, effective and efficient execution of concept shops, merchandising, POS displays and fixture programs.
Feb 2016 - Present
Duggal provides innovative retail marketing solutions for powerful brands across the nation. Specializing in high impact visual solutions in digital signage, 2D and 3D. I am responsible for supporting all aspects of business in the western region.
Feb 2012 - P November 2015
Direct a team of individuals to manage business growth, brand development, strategic planning and implementation of creative solutions. Monitor overall client activity levels and sales forecasts by holding weekly sales meetings. Report directly to the CEO and work with other members of the leadership team to meet or exceed established benchmarks.


Congratulations on reaching the final project of the Robotics Nanodegree!
Previously, you worked on the Semantic Segmentation lab where you built a deep learning network that locates a particular human target within an image. For this project, you will utilize what you implemented and learned from that lab and extend it to train a deep learning model that will allow a simulated quadcopter to follow around the person that it detects!
Most of the code below is similar to the lab with some minor modifications. You can start with your existing solution, and modify and improve upon it to train the best possible model for this task.
You can click on any of the following to quickly jump to that part of this notebook:
We have provided you with a starting dataset for this project. Download instructions can be found in the README for this project's repo. Alternatively, you can collect additional data of your own to improve your model. Check out the "Collecting Data" section in the Project Lesson in the Classroom for more details!
import os
import glob
import sys
import tensorflow as tf
from scipy import misc
import numpy as np
from tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import layers, models
from tensorflow import image
from utils import scoring_utils
from utils.separable_conv2d import SeparableConv2DKeras, BilinearUpSampling2D
from utils import data_iterator
from utils import plotting_tools
from utils import model_tools
In the Classroom, we discussed the different layers that constitute a fully convolutional network (FCN). The following code will introduce you to the functions that you need to build your semantic segmentation model.
The Encoder for your FCN will essentially require separable convolution layers, due to their advantages as explained in the classroom. The 1x1 convolution layer in the FCN, however, is a regular convolution. Implementations for both are provided below for your use. Each includes batch normalization with the ReLU activation function applied to the layers.
def separable_conv2d_batchnorm(input_layer, filters, strides=1):
output_layer = SeparableConv2DKeras(filters=filters,kernel_size=3, strides=strides,
padding='same', activation='relu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
def conv2d_batchnorm(input_layer, filters, kernel_size=3, strides=1):
output_layer = layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,
padding='same', activation='relu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
The following helper function implements the bilinear upsampling layer. Upsampling by a factor of 2 is generally recommended, but you can try out different factors as well. Upsampling is used in the decoder block of the FCN.
def bilinear_upsample(input_layer):
output_layer = BilinearUpSampling2D((2,2))(input_layer)
return output_layer
In the following cells, you will build an FCN to train a model to detect and locate the hero target within an image. The steps are:
encoder_block
decoder_block
Create an encoder block that includes a separable convolution layer using the separable_conv2d_batchnorm()
function. The filters
parameter defines the size or depth of the output layer. For example, 32 or 64.
def encoder_block(input_layer, filters, strides):
# TODO Create a separable convolution layer using the separable_conv2d_batchnorm() function.
output_layer = separable_conv2d_batchnorm(input_layer, filters, strides)
return output_layer
The decoder block is comprised of three parts:
def decoder_block(small_ip_layer, large_ip_layer, filters):
# TODO Upsample the small input layer using the bilinear_upsample() function.
unsample = bilinear_upsample(small_ip_layer)
# TODO Concatenate the upsampled and large input layers using layers.concatenate
concat = layers.concatenate([unsample, large_ip_layer])
# TODO Add some number of separable convolution layers
output_layer = separable_conv2d_batchnorm(concat, filters)
output_layer = separable_conv2d_batchnorm(output_layer, filters)
return output_layer
Now that you have the encoder and decoder blocks ready, go ahead and build your FCN architecture!
There are three steps:
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
el1 = encoder_block(inputs,32,2)
el2 = encoder_block(el1, 64, 2)
#el3 = encoder_block(el2, 128, 2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
one_to_one = conv2d_batchnorm(el2, 128, 1,1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
dl1 = decoder_block(one_to_one, el1, 64)
dl2 = decoder_block(dl1, inputs,32)
#dl3 = decoder_block(dl2, inputs, 32)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(dl2)
The following cells will use the FCN you created and define an ouput layer based on the size of the processed image and the number of classes recognized. You will define the hyperparameters to compile and train your model.
Please Note: For this project, the helper code in data_iterator.py
will resize the copter images to 160x160x3 to speed up training.
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
image_hw = 160
image_shape = (image_hw, image_hw, 3)
inputs = layers.Input(image_shape)
num_classes = 3
# Call fcn_model()
output_layer = fcn_model(inputs, num_classes)
Define and tune your hyperparameters.
learning_rate = 0.002
batch_size = 32
num_epochs = 30
steps_per_epoch = 173
validation_steps = 37
workers = 2
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# Define the Keras model and compile it for training
model = models.Model(inputs=inputs, outputs=output_layer)
# weight_file_name = 'model_weights'
# model = model_tools.load_network(weight_file_name)
model.compile(optimizer=keras.optimizers.Nadam(learning_rate), loss='categorical_crossentropy')
# Data iterators for loading the training and validation data
train_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,
data_folder=os.path.join('..', 'data', 'train'),
image_shape=image_shape,
shift_aug=True)
val_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,
data_folder=os.path.join('..', 'data', 'validation'),
image_shape=image_shape)
# logger_cb = plotting_tools.LoggerPlotter()
# filepath="weights-improvement-{epoch:02d}-{val_loss:.2f}.hdf5"
# checkpoint_cb = keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=1, period=1)
# callbacks = [logger_cb,checkpoint_cb]
logger_cb = plotting_tools.LoggerPlotter()
callbacks = [logger_cb]
model.fit_generator(train_iter,
steps_per_epoch = steps_per_epoch, # the number of batches per epoch,
epochs = num_epochs, # the number of epochs to train for,
validation_data = val_iter, # validation iterator
validation_steps = validation_steps, # the number of batches to validate on
callbacks=callbacks,
workers = workers)
# Save your trained model weights
weight_file_name = 'model_weights'
model_tools.save_network(model, weight_file_name)
Now that you have your model trained and saved, you can make predictions on your validation dataset. These predictions can be compared to the mask images, which are the ground truth labels, to evaluate how well your model is doing under different conditions.
There are three different predictions available from the helper code provided:
# If you need to load a model which you previously trained you can uncomment the codeline that calls the function below.
# weight_file_name = 'model_weights'
# restored_model = model_tools.load_network(weight_file_name)
The following cell will write predictions to files and return paths to the appropriate directories.
The run_num
parameter is used to define or group all the data for a particular model run. You can change it for different runs. For example, 'run_1', 'run_2' etc.
run_num = 'run_1'
val_with_targ, pred_with_targ = model_tools.write_predictions_grade_set(model,
run_num,'patrol_with_targ', 'sample_evaluation_data')
val_no_targ, pred_no_targ = model_tools.write_predictions_grade_set(model,
run_num,'patrol_non_targ', 'sample_evaluation_data')
val_following, pred_following = model_tools.write_predictions_grade_set(model,
run_num,'following_images', 'sample_evaluation_data')
Now lets look at your predictions, and compare them to the ground truth labels and original images. Run each of the following cells to visualize some sample images from the predictions in the validation set.
# images while following the target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','following_images', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
# images while at patrol without target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','patrol_non_targ', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
# images while at patrol with target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','patrol_with_targ', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
Evaluate your model! The following cells include several different scores to help you evaluate your model under the different conditions discussed during the Prediction step.
# Scores for while the quad is following behind the target.
true_pos1, false_pos1, false_neg1, iou1 = scoring_utils.score_run_iou(val_following, pred_following)
# Scores for images while the quad is on patrol and the target is not visable
true_pos2, false_pos2, false_neg2, iou2 = scoring_utils.score_run_iou(val_no_targ, pred_no_targ)
# This score measures how well the neural network can detect the target from far away
true_pos3, false_pos3, false_neg3, iou3 = scoring_utils.score_run_iou(val_with_targ, pred_with_targ)
# Sum all the true positives, etc from the three datasets to get a weight for the score
true_pos = true_pos1 + true_pos2 + true_pos3
false_pos = false_pos1 + false_pos2 + false_pos3
false_neg = false_neg1 + false_neg2 + false_neg3
weight = true_pos/(true_pos+false_neg+false_pos)
print(weight)
# The IoU for the dataset that never includes the hero is excluded from grading
final_IoU = (iou1 + iou3)/2
print(final_IoU)
# And the final grade score is
final_score = final_IoU * weight
print(final_score)


Register
Fill the form to create an account.
Email
Password
Repeat Password
Please select your gender:
Male
Female
Other
Register


--- title: Rainfall map description: Average rainfall of the Island in OpenLeayers and Bing Maps img: prop_rainfall.jpg layout: map type: proposed application: OpenLayers base_layer: Bing Maps layer: KML purpose: Present the rainfall map. ---


Match Play. Red leads 4-0 to 7. Should Red double? If doubled, should White take?
pips Red=136 White=145
(CorrectAnswer= 0/0, ErrorScore= 0)
For money this is obviously double and pass. At this score Red should consider whether he is strong enough to play on for an undoubled gammon. The answer to that is not quite, mainly because of White’s 2-pt anchor. However, Red is strong enough to double.
The second question is can White take the double? The answer, perhaps surprisingly, is yes and comfortably. Because of the score Red is, in fact, only just strong enough to double. White would blunder by dropping. He has the 2-pt anchor and all his checkers in play. In some variations he can create his own prime. The other key point is that he will be redoubling very aggressively.
So, close double and easy take.
The second question is can White take the double? The answer, perhaps surprisingly, is yes and comfortably. Because of the score Red is, in fact, only just strong enough to double. White would blunder by dropping. He has the 2-pt anchor and all his checkers in play. In some variations he can create his own prime. The other key point is that he will be redoubling very aggressively.
So, close double and easy take.
Cube analysis 2-ply cubeless equity +0.676 (Money: +0.673) 0.779 0.165 0.007 - 0.221 0.055 0.002 Cubeful equities: 1. No double +0.829 2. Double, pass +1.000 (+0.171) 3. Double, take +0.806 (-0.023) Proper cube action: No double, take (12.0%)


Hello, I'm Jane Chen.
I'm pursuing a Master Degree of Electrical Engineering in National Taiwan University of Science and Technology.
My research topic involves Cyber Security and Artificial Intelligence Architecture.
I love code, because I love to solve problems.
If you’d like to know more about me, please check out my LinkedIn.


This is an web-app which the goal is make safer the use of BitCoin. Make the use of a E-Coin's currency much safer than a Government's currency. How? We will tell you when to sell or buy your BitCoins and maybe explain why. Feel Free to use.
The value of was the minimum value reached this day to BitCoin.
The value of was the minimum value reached this day to LiteCoin.
The value of was the minimum value reached this day to BitCoin.
The value of was the minimum value reached this day to LiteCoin.


{% set text = 'Moon Rider (v2.9)\n\n' %}
{% set text = text + 'Open source demonstration codebase of a VR app built in HTML and JavaScript running on the Web.\n\n' %}
{% set text = text + 'A side project built by two people in a few months as a resource for A-Frame developers. ' %}
{% set text = text + 'Not meant to be an official, paid, nor fully released product.\n\n' %}
{% set text = text + 'Song maps sourced from beatsaver.com. Supports most browsers and headsets (including Quest).\n\n' %}
{% set text = text + 'This game was meant to serve as an example of a VR app running inside a webpage to help progress the open WebXR initiative (bsaber.com/moonrider).\n\n' %}
{% set text = text + 'Chat with us on moonrider.xyz/discord' %}