text:
Newest Oldest Title (A-Z) Title (Z-A) Most Comments
Utawarerumono: Prelude to the Fallen Review
Utawarerumono: Prelude to the Fallen Developer: AquaplusPublisher: NIS AmericaPlatforms: PlayStation 4 (Reviewed), PS VitaRelease Date: Available NowPrice: $59.99 – Available Here Overview The Utawarerumono series has always had a somewhat unique barrier to entry for those who have wanted to see what it has to offer. The first game in the series was released long ago in 2002 as an eroge in J...
Travis Bruno July 16, 2020 No Comments
Utawarerumono: Prelude to the Fallen Arrives Late May in the West
News Playstation 4 Videos PS Vita RPG Strategy NIS America
NIS America has announced that they are planning on releasing Utawarerumono: Prelude to the Fallen in the West this May with the game releasing in North America on May 26th and May 29th in Europe with both the PlayStation 4 version and surprisingly PS Vita version coming out on those days. The PlayStation 4 version of the game will be released both physically and digitally while the PS Vita versio...
Travis Bruno February 14, 2020 No Comments
Corpse Party: Blood Drive Heads to Switch and PC October 10
PC News Videos Switch PS Vita Horror XSEED Games
XSEED Games has announced that they are planning on releasing Corpse Party: Blood Drive on the Nintendo Switch through the eShop as well as on PC on October 10th where the game will be priced at $19.99. Originally released for the PlayStation Vita back in 2015 Corpse Party: Blood Drive takes place two months after the events of Corpse Party: Book of Shadows and serves as the definitive conclusion ...
Travis Bruno October 4, 2019 No Comments
Shakedown: Hawaii Review
Shakedown: Hawaii Developer: Vblank EntertainmentPublisher: Vblank EntertainmentPlatforms: PS Vita, PlayStation 4, Nintendo Switch, PC (Reviewed)Release Date: Available NowPrice: $19.99 – Available Here Overview Taking a relatively played out genre and putting a new spin on things is a great way to draw attention and when Retro CIty Rampage blew onto the scene back in 2012 it proved that top...
Travis Bruno June 7, 2019 No Comments
Utawarerumono: Prelude to the Fallen Western Release Planned for 2020
Last year the original game in the Utawarerumono series was enhanced and released in Japan and now NIS America has announced that they will be bringing that game to the West in early 2020. The company will be releasing the game physically and digitally for the PlayStation 4 and digitally for the PS Vita where it will feature Japanese voice work and English subtitles. Utawarerumono: Prelude to the ...
Travis Bruno March 15, 2019 No Comments
Chaos;Child Review
Chaos;Child Developer: 5pb Publisher: Spike Chunsoft Platforms: PlayStation 4, PlayStation Vita, PC (Reviewed) Release Date: Available Now Price: $34.99 – Available Here Overview For many, Japanese visual novels tend to be a genre that can be hit or miss. This is primarily due to the fact that there are so many out there and until about five or six years ago the titles that were translated i...
Punch Line Game Announced for Western Release
News PC Adventure Playstation 4 Videos PS Vita
PQube has announced that they are planning on releasing the visual novel adventure game, Punch Line in the West sometime this summer for the PlayStation 4, PS Vita, and PC. Some of you may recognize this title as it was given an anime adaptation/advertisement back when it was originally released in Japan. PQube describes Punch Line as a game where players will take control of Yuuta Iridatsu, a hig...
Travis Bruno May 7, 2018 No Comments
The Legend of Heroes: Trails of Cold Steel II PC Release Planned for February 14
PC News PS Vita RPG Playstation 3 XSEED Games
XSEED Games has announced that they are planning on bringing The Legend of Heroes: Trails of Cold Steel II to PC through Steam, GOG, and the Humble Store on February 14th. For one week after launch the game will be sold at a 10% discount but after that it will be sold at the regular price of $39.99 / €39.99 / £29.99. Originally released in the West for the PlayStation 3 and PS Vita in November 201...
Travis Bruno February 4, 2018 No Comments
Utawarerumono Remake Debut Trailer Released
News Playstation 4 Videos PS Vita RPG Strategy
After the last two games in the trilogy were released in Japan and the West, Aquaplus has revealed plans to bring the original title, Utawarerumono: Chiriyuku Mono he no Komoriuta to current day fans in the form of a PlayStation 4 and PS Vita release. Currently a Western release has not been announced but the game has been set for release in Japan on April 26th. With this upcoming release Aquaplus...
Romancing Saga 2 Coming to PC, PS4, PS Vita, Switch, and Xbox One
PC News Playstation 4 Videos Xbox One Switch PS Vita RPG Square Enix
A remastered version of classic Super Famicom RPG Romancing Saga 2 has been in the works for western audiences for some time. An iOS and Android version was released last year, but the console versions has been hit with a few delays. It seems like the delays are about to pay off for gamers, as Romancing Saga 2 will be coming to more platforms than just the originally announced PS Vita. Romancing S...
Jamie Laike Tsui December 9, 2017 No Comments
Atelier Lydie & Suelle: The Alchemists and the Mysterious Paintings Opening Movie Revealed
PC News Playstation 4 Videos Switch PS Vita RPG Koei Tecmo
With Atelier Lydie & Suelle: The Alchemists and the Mysterious Paintings set to be released in a few months in Japan, Koei Tecmo and Gust have decided to release the opening movie for the game. The title follows the story of a pair of twin sisters who run a small atelier inside the capital city of Adalett Kingdom only for their world to grow much larger once they find a strange painting that c...
Travis Bruno November 1, 2017 No Comments
Mary Skelter: Nightmares Review
Mary Skelter: Nightmares Developer: Compile Heart Publisher: Idea Factory International Platform: PS Vita Release Date: Available Now Price: $39.99 – Available Here Overview The fairy tales that many of us grew up with throughout the years have been told in many forms, ranging from child friendly to even more twisted than the originals. Both Western and Japanese developers have had their fai...
Travis Bruno October 31, 2017 No Comments


Are all your products returnable, or do some restrictions apply?
Set the time limits for returns.
Tell your customers how to return items and what documentation they need.
Are original shipping rates refundable? Does the customer pay for shipping the return?
Set how your customer will be credited for returned items.


text:
Defending the Living Room from Apple
The biggest threat to smart gaming, says Valve's Gabe Newell, is for Apple to seize the living room.
David Zaxarchive page
I don't often have occasion to embed a video from the LBJ School of Public Affairs on Technology Review. But when the enigmatic and brilliant Gabe Newell–CEO of the gaming company Valve and one of the smartest people in tech today–gives a talk at the University of Texas school, then it's worth your attention.
I've written a bit before about Newell's recent forays into the world of hardware (see "Is Valve Making a Console?" and "Can Valve Innovate Gaming Hardware?"). Generally, Newell–whose company is behind both some of the greatest gaming franchises in history ("Half Life," "Portal") and a novel indie game distribution platform called Steam–has emerged as a voice in favor of openness in a gaming ecosystem that is increasingly closed. Valve has been said to be interested in making a gaming console of its own, a yet-to-be-released "Steam Box" whose specs are still nebulous, but is likely to have more in common with a traditional PC than with an Xbox or PlayStation. (The best place to get a sense of what the Steam Box is and isn't is in this Verge interview from January.)
One comment of his in particular during his LBJ talk is attracting a lot of note. One would think that the natural competition for a new console would be the legacy players in the console business. Not so, says Newell:
"The threat right now is that Apple has gained a huge amount of market share, and has a relatively obvious pathway towards entering the living room with their platform… I think that there's a scenario where we see sort of a dumbed down living room platform emerging — I think Apple rolls the console guys really easily. The question is can we make enough progress in the PC space to establish ourselves there, and also figure out better ways of addressing mobile before Apple takes over the living room?"
I'm a gamer, though something of an unusual one, in two senses. My tastes run towards the highfalutin. I'd rather play one amazing, ambitious game every year or two years than a dozen mindless games a month (though I did get addicted to Harbor Master for a couple hours the other night, if I'm being honest). "Portal 2" was the last console game I played through in its entirety; I wouldn't be surprised if "Portal 3" were the next, so rarely does a game come around that seizes me like a great TV show or novel.
All of which is to say that my tastes may not be a good indication of what markets actually wants. But I do worry about an era in which the sorts of games I see people play on their iPhones or iPads become the dominant form of gaming in the living room, as well. I think that gaming wields considerable cultural influence, and that our culture will be richer if it has more "Portals" than "Angry Birds." We are already becoming a nation of zombies, glued to our various screens; we should at least be semi-cultured zombies, if we can (see "The Rise of Social Mobile Games.")
Then again, "The Last Express," one of the most daring and brainy games of all time, has found a second lease on life through iOS. Does Apple and its closed ecosystem necessarily shunt us into "dumbed down" gaming, as Newell suggests? Will the living room, with its larger screen, its inherent non-mobility (unless you live in an RV!), always be a welcome venue for smart games, no matter what operating system or console they run on?
In fact, the Apple rant was only a small part of Newell's much longer and thought-provoking talk, which is about the economics of gaming, his hiring philosophy, and much else (like the idea of opening up Steam even more radically, Android-style). Like most of Newell's pronouncements, it merits a listen, at least:
by David Zax

redpajama_set_name: RedPajamaCommonCrawl


A trip to Astley Green on Saturday 24th November, fortunately a nice day. Astley Green is a village near Leigh just off the A580, a major road. The mine was closed in 1970 after some 60 years of work. The whole area was full of mines and the tunnels of this mine spread around 3 miles east at a depth of a mile. There's still plenty of coal down there.
The Mining Museum has been around a long time and the greatest feature is the Mine Head Gear, closely followed by the winding machine which has been carefully restored.
On arrival we were greeted by Marilyn who enthusiastically told us about the mine and then brought in Alan who did a guided tour. Alan showed us the mining equipment scattered around the site. The mine walls were held up by metal tunnel structures and the trains that carried coal and miners to and from the pithead were there, as well as cutting machinery.
The pithead structure needs around half a million to restore it and it certainly is impressive. Next to that is the winding machine that pulled the lifts at up to 60mph, 20mph if with men, which has been magnificently restored.
At the moment work is proceeding on getting the shunting trains going on a track around the site.
There is a dining room and a re-created mining family home and various mining items to see as well. A tea or coffee was offered at the pop up cafe.
This entry was posted in Heritage, Industrial, Travel and tagged Astley Green, Lancashire Mining Museum. Bookmark the permalink.


text:
Home All Specialties Pulmonology
Misperceptions about prognosis among surrogates of critically ill patients
byMichael Milligan
in Pulmonology
1. Discordant expectations about a critically ill patient's prognosis were common among surrogate decision makers and were due both to a surrogate's misunderstandings of the physician's assessment and differences in belief systems.
2. Prognostic estimates by surrogates were significantly more accurate than random chance, but were less accurate than physician estimates.
Study Rundown: Critically ill patients at the end of life are often unable to make their own decisions about medical care. In these instances, family members and loved ones are called upon to act as surrogate decision makers. It has been shown that surrogates tend to be overly optimistic about the patient's prognosis, which can lead to greater utilization of invasive treatments and delays in palliative care.
This study sought to quantify the degree of discordance among surrogates and physicians about patient prognosis, and to identify the causes of these misperceptions. Among critically ill patients without decision-making capacity, discord was identified in 53% of cases. In most instances, this discord was due to surrogates misunderstanding of the clinical assessment as well as differences in beliefs (i.e., religious beliefs, a patient's perceived unique strengths, and more). While surrogates were able to estimate a patient's prognosis better than random guessing, their predictions were not as accurate as a physician's.
This study, though limited by its use of qualitative data among critically ill patients in a single ICU, indicates that there is a high prevalence of discordance about prognosis between physicians and surrogate decision makers. It follows that to improve agreement—and to potentially improve end-of-life outcomes—physicians should regularly meet with surrogates to explore their clinical understanding and belief system. This study also points to the root causes of discord and suggests possible interventions.
22q11.22 status is a predictor of the degree of negative outcomes of IKZF1 alteration in pediatric B-cell acute lymphoblastic leukemia
Survivors of intensive care unit admissions may have increased risk of self-harm and suicide
Time-limited trials may decrease the length of stay of critically ill patients in the intensive care unit
Relevant Reading: Advance directives and outcomes of surrogate decision making before death
In-Depth [prospective cohort]: This study enrolled physicians and surrogate decision makers involved in the care of 174 critically ill patients at a single hospital. Patients who had been in the ICU for 5 days were eligible for this study if they were on mechanical ventilation and had at least a 40% chance of dying as calculated by their APACHE-II score. A total of 229 surrogates and 99 physicians involved in the care of these patients were analyzed. Physicians recorded their prognosis as a probability that the patient would survive their hospitalization. Without conferring, surrogates also indicated their perceived prognosis, as well as their best guess of the physician's prognosis. Misunderstandings were defined as large differences between a physician's estimate and a surrogate's guess at the physician's estimate. Belief differences were defined as large differences between a surrogate's prognosis and their guess at the physician's prognosis. Surrogates were then interviewed about the experience.
Discordance of at least 20% difference in estimated prognosis was evident in 53% of cases (95%CI 46.8% – 59.7%). A majority (53%) of disagreements were due to both misunderstandings and belief differences. While both surrogates and physicians were able to predict prognosis more accurately than by chance alone, physicians were more accurate (c statistic 0.83 vs. 0.74, p = 0.008).
Image: CC/Wiki
Tags: intensive careprognosis
Diabetic foot ulcers associated with worsening cognitive decline
Endobronchial coiling for emphysema associated with moderate improvement in exercise tolerance
2 Minute Medicine
No mortality benefit found for hydroxychloroquine or tocilizumab for the treatment of COVID-19
Aspirin does not decrease the incidence of ARDS in at-risk patients
Seasonal temperature variations may affect glucose tolerance in pregnancy


Leribisi Lodge Conference Venues Pretoria provides 4 venues for any kind of function. We can help you to just sit back and relax while we take care of your function at one of our venues.
Leribisi Spitbraai Venues Pretoria caters for 10 to 170 delegates for a spitbraai party. Our professional staff will see that your spitbraai will be awesome and enjoyable. Situated in Pretoria East on the outskirts, these venues can be your escape to the bush.
Leribisi Spitbraai Lapa Venues Pretoria can make a spitbraai for 10 to 350 delegates. Situated on the outskirts of Pretoria East. Our professional staff is available to assist you with your spitbraai function.
At leribisi lodge our facilities are perfect for meetings large & small. We boast a variety of in-house meeting venues to suit every occasion imaginable, from the gracious Hall that can accommodate up to 120 people, to a breakfast meeting with your colleagues in the Lapa with Boma area.
Leribisi Wedding Venues Pretoria can assist with all your wedding needs. Your wedding marks one of your life's most memorable moments! Leribisi lodge is a wedding venue in Pretoria that offers an idyllic setting during one of the most wonderful and memorable days of your life. The Lodge has a very personal feel with ample photography possibilities.
Celebrate in style in our big Wedding Hall or choose an idyllic garden setting in the gazebo with nature as the perfect backdrop. We have a charming stone thatched-roof chapel on the premises. Leribisi Lodge is different from the general commercialised venues and can cater for your individual needs with exceptional service.
In conclusion, Leribisi Wedding Venues Pretoria can cater to all your needs.
Leribisi Family Reunion Venues Pretoria is the potentially perfect venue for that long overdue family reunion or gathering of close friends. The Lapa with Bonfire is perfect for a great family reunion get-together, a cosy ladies session or even a child-friendly picnic party.
Hire it on a regular basis for beautiful family bonding socials. Cool down in our newly renovated sparkling pool. There's no limit to the possibilities.
Corporate Retreats Venues Pretoria - Leribisi is imperative for emerging businesses and veteran companies alike. Many top-performing companies schedule mini leader retreats quarterly and more involved staff retreats annually.
In general, the more unique the environment, the better it will be for shifting attention away from daily business and personal demands to the open- and creative-minded focus of retreats. Leribisi Lodge is the ideal venue for these types of retreats.
Inconclusion, Corporate Retreats Venues Pretoria - Leribisi is the perfect place.
Leribisi Lodge Conference Venues Pretoria can cater for large and small conferences, seminars, launches, exhibitions, graduation ceremonies, breakfast presentations, cocktail events, gala dinners and IT training. The conference centre is conveniently located just off Garsfontein Drive.
Well-known for our excellent facilities and professional service, we are perfectly placed to deliver memorable events for you and your guests. Our multi-purpose venue accommodates delegates in a variety of function formats.
Nestled in the scenic Tierpoort area lays Leribisi Lodge. Owner-run, it has a personal, exclusive feel complemented by beautiful and unique gardens and surrounded by indigenous bushveld.
Select from multiple venues to host your wedding ceremony and reception, or your special function. Accommodation is lush and comfortable, giving a unique sense of peace, tranquillity and privacy.
We are delighted that you have chosen to explore Leribisi Lodge as the setting for your special occasion! We are the perfect venue to celebrate all of life's important events with a party.
Whether it's a 21st birthday, bachelor/bachelorette, and engagement party, or wedding... At leribisi Lodge we have an array of options and menus to choose from to suit your style and budget!
It's that time of the year again! The year is drawing to a close and arrangements are being put in place for your company's year-end function. A year end function is a time to show your appreciation to those employed as well as to those who show you continuous support throughout the year.
We put all our skills and creativity in guaranteeing you a full service experience, offering you the most incredible selection of delicious foods and options to choose from. Put the fun back into your function at Leribisi Lodge!
Leribisi Lodge is a beautiful and unique venue set in a natural environment and is a well established, highly recommended team building venue in Pretoria.
Team building in Pretoria East, with plenty of fun team building activities that you can use for your business to enhance employee creativity, productivity and camaraderie.
The overall goals of team building are to increase the teams understanding of team dynamics and improve how the team works together.
Nestled away in the breathtaking Tierpoort area, east of Pretoria, Leribisi Lodge is a party venue for fun land unique events. A mere stone's throw away from Pretoria CBD and 14km from Menlyn Park, you are surrounded by indigenous bushveld in the beautiful countryside.
The lawns give the children vast open spaces to allow them to run and play unrestricted and safely. Here we would love you to feel at home and watch how your kids enjoy nature and the party while you relax.
If you are looking for that surprisingly good Youth Camp Venue, school outing and leadership course, or a great venue for your church or youth camps, come experience the peace and tranquillity that so many say is evident here at Leribisi Lodge.
Our friendly staff work hard to present you with a beautiful clean environment. We pride ourselves on bringing you the best camp food ever! Our mission is to provide an excellent facility and outstanding service to assist our learners to achieve their desired outcomes for their camp.
Try Leribisi Lodge for budget accommodation - neat and clean dormitories for large groups, with the benefit of large meeting halls and optional catering. Come and enjoy fellowship with your special group for a day, or make it an exclusive weekend affair.
Choose from en-suite rooms or stylish, fully-equipped chalets and cottages for a peaceful retreat in picturesque surroundings, or just escape for the day to have your meeting or church camp in low-key country style.
At Leribisi Lodge Pretoria you focus on the training - our team will take care of everything else. Pick from several seating arrangements, to suit all learning styles - from team-building exercises to motivational speeches to presentations. You can book a room for however long you need it.
Catering services are available and use of an LCD projector and screen if required.
leribisi Mahindra 4 x 4 Off Road Training Academies specializes in professional 4x4 Offroad training and team building and is intensively involved with every student learning by us. Results are confirmed by practical load measurements. This provides us with first-hand knowledge and skills to train with confidence from the novice to the very experienced. The greatest value of the Leribisi Mahindra training would be the correct use of a 4WD both on-road and off-road to save lives, to stay within the limits of the vehicle and to protect the environment with our high and green standards.
In conclusion, when it comes to 4 x 4 Off Road Training Academies we are the best.


text:
Home » Blogs » Dr. Jennifer Fraser's blog
Students with Learning Disabilities at Risk for Teacher Bullying
Sep 10 by Dr. Jennifer Fraser
We learned from other students' testimonies that our son was regularly hauled up in front of the basketball team for one-on-one sessions with the coach who would yell rhetorical questions in his face along the lines of "Do you even like basketball? Do you even deserve to play? You're the best player out there, you're not trying!" According to student reports, when our son tried to get away, the coach would restrain him for more in-the-face humiliation. The other coach would watch. Students reported that they wanted to stop what was happening, but they felt powerless because the bully was a teacher and he was their coach.
Our son has a Learning Disability and according to the experts, as recorded in government documents on bullying and child abuse, he is more vulnerable and at risk because of it. He's less likely to speak up and defend himself [1]. However, when we submitted the students' reports to the Commissioner for Teacher Regulation, the teacher's conduct was not publicly addressed, nor were future students seen as needing protection. This kind of teacher conduct was condoned.
Our son has Dysgraphia. It was identified when he was finishing grade 6 and he was so relieved because it meant that his learning frustrations could be remedied with access to a computer and extra time on tests. Dysgraphia means in layman's terms that the student has no problem reading, but finds it challenging to put ideas into words especially under time pressure. Our son also discovered that he was more of an auditory learner. So when he listens to a book, his recall is almost perfect; whereas when he textually absorbs material, the recall is more challenging. His auditory learning style may have made him more sensitive to adults' yelling.
As an eleven year old, he informed the Educational Psychologist who did the testing for his learning disability that he felt very anxious about his basketball coaches because they were constantly yelling. The Educational Psychologist was concerned and said that I should speak to the coaches about their approach about how it was negatively impacting our son. I wrote an email to them and touched base with the Athletic Director at the school to see if they could accommodate our son's sensitivity to yelling as a coaching method. Neither coach responded to my email, but when I encountered one of them in passing, he yelled at me in a fury that I would dare ask for our son to be shielded from their way of coaching. I was new at the school as a teacher and felt confused as if I had done something wrong. I kept quiet after that.
Our son started doing fabulously in his academics. He earned major awards for his learning in grades seven and eight. He set as a goal getting onto the Headmaster's Honor Roll and achieved it.
As a fifteen year old, our son had to have the Learning Disabilities assessment done again so it would carry his accommodations---computer use and extra time---into his university courses. This time he did not say anything to the Educational Psychologist about his experiences playing basketball for coaches who screamed incoherently, repeatedly expressed disgust at players' performances, muttered obscenities, swore, shunned and ostracized certain players. We only learned about this conduct from detailed student testimonies a year later. However, our son's learning assessment should have been a red flag because he had gone into serious decline as a student: "his spelling skills and skills of reading comprehension are significantly weaker now than in 2007 (when compared to age expectations). Moreover, [he] now experiences mild attentional challenges."
We could not understand how our bright child, previously focused and confident was in decline. The key lesson in this is an eleven year old might speak up about teacher abuse, but a fifteen year old who hopes to play basketball at college knows that if he reports the coach is abusive, he might lose his chance for playing time, scholarship opportunities, letters of reference, phone calls made to university coaches. Teachers and coaches are in a significant power imbalance with students.
The teenager knows that far too often victims are held responsible for the actions of bullies. Teens know well enough that the system has a bad habit of flipping it around so that students who report are seen as a problem because their speaking up will affect the reputation of the teacher or coach and therefore the school, so they learn it's best to put their heads down and suffer. It's best to look the other way when they witness teachers or coaches bullying certain targeted students.
However, it wasn't just our son, there were many parents and many students reporting. Students across five years were describing the same bullying conduct done by their teachers under the auspices of coaching. We believed the system, namely the Headmaster, the Chaplain, the Director of the Senior School and certainly the Commissioner for Teacher Regulation would step in and stop what multiple students were describing as a clearly abusive situation in the basketball programs.
We were wrong.
Student reports of teachers calling players "f----- retards, f---- pussies, f----- pathetic, f---- embarrassments" and so on were minimized and dismissed as part of a sports culture with the help of lawyers and the Commissioner for Teacher Regulation.
Scientists at McMaster University refer to this kind of attack on a child as relational bullying: "Many parents, educators, and health professionals are familiar with physical and verbal forms of bullying. However, it also is bullying when a child uses ostracism, rumour spreading, or gossip to sabotage another child's peer relationships and isolate him or her from the peer group. This type of bullying, called relational bullying, can be just as harmful to a child as being physically harassed or attacked." [1] Like the vast majority of studies, this one is focused on peer bullying. One can only imagine that the harmful impact caused by bullying is exponentially intensified when the bullying comes from an adult in a powerful position such as coach, teacher, or Headmaster.
Our son nearly collapsed as a student and as a person. With the claims of anonymous students, published widely by the Headmaster, that he had told "nasty lies" and had "manufactured evidence," he started having panic attacks if he needed to simply write a math test. Our son would avoid going to classes if he had to present something. He was diagnosed with PTSD by an experienced sports psychology expert. He was exempted from exams in grade 11 and 12. His reaction to bullying is typical and well-documented by researchers. "Research shows that bullying can negatively impact a child's access to education and lead to:
• School avoidance and higher rates of absenteeism
• Decrease in grades
• Loss of interest in academic achievement
• Increase in dropout rates" [2]
When our son went off to university, we had no hope that he would survive. We were sure within a month or two he'd have to come back home.
In an environment where he wasn't being bullied by teachers, administrators and then peers---who were modeling their conduct on the adults---our son flourished. In first year, he slowly but surely learned again to trust his own abilities, to concentrate, to handle anxiety. In second year, he fought his way onto the Dean's List. Only one thousand students out of twenty thousand have a high enough GPA to get on the list at his university. He is exceptionally bright and strong-minded to not let a learning disability or previous educational bullying hold him back.
Learning Disabilities may actually be Learning Exceptionalities. We might be losing some of our top students and top athletes by simply expecting them to submit to whatever teaching style we deem best. A cookie cutter method for teaching is not only outdated, but it has the power to significantly harm certain learners who don't fit with the herd. These exceptional learners have many gifts that get squandered by an education system when it is rigid and formulaic [4].
Teachers and Coaches who bully can cause serious harm to student learning on the court and in the classroom and therefore should never be tolerated. Forty years of psychological, psychiatric, and neuroscientific research says bullying harms all students, not just the exceptional ones.
Notes 1. http://www.mcf.gov.bc.ca/child_protection/pdf/handbook_action_child_abuse.pdf 2. Wenonah Campbell and Cheryl Missiuna, "Bullying Risk in Children with Disabilities: A Review of the Literature," CanChild: Centre for Childhood Disability Research, 2011: https://www.canchild.ca/en/canchildresources/bullying_risk_children_disabilities.asp 3. Pacer's National Bullying Prevention Centre, "Bullying and Harassment of Students with Disabilities," http://www.pacer.org/bullying/resources/students-with-disabilities/ 4. Sean Price, "Ending Child Abuse at School," 2009: "According to the U.S. Government Accountability Office, over the last 20 years there have been hundreds of allegations of school personnel using restraint and seclusion in abusive ways on children. It's happening disproportionately to students with disabilities, often at the hands of untrained staff. Many of these students bear haunting physical and emotional scars." http://www.tolerance.org/blog/ending-child-abuse-school
Dr. Jennifer Fraser's blog
Dr. Jennifer Fraser
Bullying Expert
With a PhD in Comparative Literature, Fraser is a passionate educator, researcher and writer. Her most recent book, Teaching Bullies, is an exploration of what happens when the teacher or coach is the bully. Drawing on psychology, psychiatry, sports journalism and neuroscience, she argues that bullying done by adults—namely emotional abuse—does such significant harm it should join sexual and physical abuse in criminal code. Her new book, Teaching Bullies: Zero Tolerance on the Court or in the Classroom, is available now!
Other Bloggers You May Like
Tracey Clayton
Parent, Writer, Blogger
How to Transform Your Backyard into a Sanctuary for the Whole Family
Katherine Eskovitz
Author & Parent Educator
Have you Checked Your Wireless Device Lately?
Los Angeles Accident Lawyer
Avoiding Swimming Pool Accidents
Kids In The House
Ultimate Parenting Resource
8 Ways to Keep Your Kids Safe Online
Ash Stevens
Animal Lover, Adoring Mother
From One Wife To Another: Easy Ways To Keep Love Alive
KeepingKidsSafeSD
Firearm Storage Safety For Children At Home
Dr. Susie Wolbe
Teacher, Principal, Tutor, Therapist
Study Skills to Improve Your School Experience
Dayton Uttinger
How to Keep Your Kid Safe Online
Dr Rutherford and Molly
The Psychology of Parenting
The Secret To Successfully Working From Home With Kids
Maureen Healy
The Emotionally Healthy Child
Cultivating Character in Children
KITH Voices
KidsInTheHouse2
Thoughtful Ways for Moms to Support Moms This Year
Elizabeth Pantley
No-Cry Solution Series Author
5 Ways New Moms Can Sleep Better
Mercedes Samudio
The Parenting Skill
Advocating for Your Child's Mental Health Care (Advocating for Your Child Series)
DrBettelheim
How to Stop Negative Emotions from Spreading Like Covid-19
Nicole McCray
Incorporating Music In Your Child's New At-Home Learning Routine
Leanne Sherred
Does My Child Have a Speech Delay? How to Recognize the Warning Signs
Winter is Coming: Is Your Furnace Ready?
Be the Hero of the Future by Taking up These Courses Today
Make Lasting Change In Your Life
Five Ways to Get Rid of your Debt


If you rely on your guns to survive disasters, then you should know how to clean and maintain the two basic types of handguns. The first is the revolver, which is a simple firearm to clean and maintain. The second firearm is the semi-auto pistol. The maintenance is not as simple as for the revolvers, but with a little bit of practice it can be mastered too.
The shooter must remember that a dirty and a not well maintained handgun is a dangerous weapon to the shooter. With neglect and poor cleaning and maintenance a handgun will begin to rust and the internal parts will weaken or possibly break. The firearm's dependability will fall and the handguns will eventually fail when you need them the most.
Let's get to work and see how you should take care of your Sig Sauer P-228 9mm Pistol.
Step 1- Lay out all needed cleaning supplies in cleaning area.
Step 2- Always visually check to make sure the pistol and all magazines are unloaded. Also remove all ammunition from the cleaning area.
Step 3- With the slide in the locked back position and an empty chamber, turn the take down lever clockwise from the 3 o'clock position down to the 6 o'clock position.
Step 4- Separate the slide from the frame by pulling the slide forward off the frame.
Step 5- The slide consists of 4 parts: the barrel, recoil spring, guide rod, and the bolt assembly.
Step 6- To remove the recoil spring and guide rod from the slide, push the guide rod forward into the slide and lift off the spring and guide rod as a unit. Be careful, because this this assembly can easily slip from your fingers and fly away from you. If it hits you in the eye it may cause an eye injury.
Step 7- Once the guide rod and spring are out of the slide it is easy to remove the barrel. This is done by gently pulling the barrel back about an inch. Then lifting upwards and backwards to remove the barrel from the slide.
Step 8- Do not remove the bolt assembly unless it is very dirty or the possibility of broken parts in the assembly. This should be done by a certified armor or gunsmith and is beyond the scope of this cleaning article.
Step 9- Set aside the slide, barrel, spring, and guide rod to be inspected and cleaned.
Step 10- The first thing to do when cleaning the frame is to use a small soft wire brush to remove dirt and grime from the slide rails.
Step 11- After finishing the frame brushing use a rag with gun cleaner on it to remove any dirt or grime that the brush did not remove.
Step 12- To clean the inside of the frame, trigger,hammer, and springs I use Q-tips with gun cleaner on them.
Step 13- Use a metal dental pick to remove dirt or grime that the Q-Tips could not remove.
Step 14- Now that the frame has been cleaned it is time to lubricate it. Put a drop of gun lubricant on all springs, spring pins, magazine release parts, slide rails, slide release parts, and hammer drop parts.
Step 15- To clean the slide, I first start by using Q-Tips with gun cleaner on them. I begin by first cleaning the bolt and firing pin assembly. After cleaning off all dirt and grime with the Q-Tips, I use a metal dental pick to remove the last traces of dirt and grime on the bolt and firing pin assembly.
Step 16- The next section of the slide to be cleaned is the front section. I use Q-Tips with gun cleaner to cleaner to clean this area. The barrel, spring, and guide rod must be well cleaned to remove dirt, grime, and powder residue. I also use Q-Tips to clean inside the slide top.
Step 17- Use Q-tips with gun cleaner to clean the slide rails.
Step 18- Lubricate the bolt and firing pin assembly lightly with a Q-Tip.
Step 19- Wipe down the inside of the slide lightly with a gun lubricant to protect and lube all surfaces.
Step 20- To clean the recoil spring and guide rod put, some gun cleaner on the assembly and wipe off with a clean rag to remove dirt, grime, and powder residue.
Step 21- When the recoil spring and guide rod are clean, lubricate with a good lubricant and wipe off the excess.
Step 22- To clean the barrel, use a wire brush dipped in gun cleaner. Clean the barrel from the back to the muzzle. Do this between 5-8 times or until the barrel is clean.
Step 23- Next run a dry patch through the barrel to remove any left over cleaner in the barrel. When this is completed, put a fresh lubricated patch on the cleaning rod. Push the patch through the barrel from the back to the muzzle.
Step 24- The last step in cleaning the barrel is to put a good gun lubricant on it and wipe off the excess with a clean rag.
Step 25- To reassemble the slide first carefully install the barrel in the front of the slide with the muzzle down and the rear facing slightly upward. Then push the barrel down and into the lower larger hole of the slide to mount the barrel in the slide.
Step 26- Next place the spring and guide rod assembly in the front of the slide in the upper hole with the excess spring side of the assembly going in first. Then compress the spring with the guide rod and place it in the guide rod holding section of the barrel.
Step 27- Reassembling the slide to the frame is done by putting the rear of the slide rail groves on to the slide rails of the frame. Continue pushing the slide up the rails until the slide is all the way back and can be held in place there with the slide release.
Step 28- Push the take down lever counter clockwise from the 6 o'clock position to the 3 o'clock position to lock the slide on the frame. Function test the pistol for proper functioning.
Step 29- Wipe down the outside of the pistol with a good gun lubricant to protect the firearm from rust, corrosion, and finger prints.
Warning To take your pistol totally apart without the proper training can be dangerous and possibly life threatening if you do not put it back together properly. If your pistol needs more in depth cleaning or maintenance take it to a certified gunsmith or armorer for these services.


Comments Off on Is the Criminal Justice System Racist?
This is an incredibly difficult question to look at, but as time goes on, it's becoming clearer that many Americans believe racism is a core issue of the criminal justice system in the United States. This is likely a jarring piece of information for many of us, but there are a lot of reasons that are usually cited in conversations. Here are just a few of the most common reasons that come up when racism and the criminal justice system are discussed.
– Minorities seem to go to jail a lot more than Caucasians, and specifically, African Americans seem to get the worst of it. Of course, some of this can be attributed to the fact that minorities are becoming a significant part of the American population.
– Financial differences. This is a huge deal, because sadly, statistics say that many people who are poor are also in minority groups. Poor people, statistically, are more likely to commit crimes, but they are also less likely to be able to afford a good lawyer, which puts the odds against them from the get go. Yikes!
– Racial differences continue to be a problem, and many people are still programmed to be uncomfortable toward those of a different race than themselves. Given that racism in the United States in general is still a problem, it should be no surprise that sometimes it leaks into the criminal justice system, whether it's in juries, lawyers, judges, or even the law enforcement officials that are dealing with the case. Even though many people say that they are trying to be unbiased, many of those same people struggle with doing so – it's a difficult balance, and sometimes rears its ugly head during criminal trials.
So, is the system inherently racist? Or are there other systems at play here that make it difficult for us to make an appropriate judgment call about the whole thing? There is, clearly, reform that has to be done in the system, but it's going to take a while before those changes go into effect (some changes include body cams, which have been tested all over the country at different police forces). The world we live in is a little more threatening than it has ever been, so it's important that we make sure that we're getting the right people, and not just those that we assume are the wrong doers.
Contact Lloyd for a Theft and shoplifting lawyer in Dallas.
Does the Justice System Work?
What Are Your Options When Your Marriage Fails?
Copyright © 2019 Under Penalty of Catapult. All Rights Reserved.


text:
"""
Simple Training CLI.
"""
import argparse
import os
import shutil
import sys
import tempfile
from contextlib import ExitStack
from typing import Any, cast, Optional, Dict, List, Tuple

import mxnet as mx

from . import arguments
from . import checkpoint_decoder
from . import constants as C
from . import convolution
from . import coverage
from . import data_io
from . import decoder
from . import encoder
from . import initializer
from . import loss
from . import lr_scheduler
from . import model
from . import rnn
from . import rnn_attention
from . import training
from . import transformer
from . import utils
from . import vocab
from .config import Config
from .log import setup_main_logger
from .optimizers import OptimizerConfig
from .utils import check_condition

# Temporary logger, the real one (logging to a file probably, will be created in the main function)
logger = setup_main_logger(__name__, file_logging=False, console=True)

def none_if_negative(val):
    return None if val < 0 else val

def _list_to_tuple(v):
    """Convert v to a tuple if it is a list."""
    if isinstance(v, list):
        return tuple(v)
    return v

def _dict_difference(dict1: Dict, dict2: Dict):
    diffs = set()
    for k, v in dict1.items():
        # Note: A list and a tuple with the same values is considered equal
        # (this is due to json deserializing former tuples as list).
        if k not in dict2 or _list_to_tuple(dict2[k]) != _list_to_tuple(v):
            diffs.add(k)
    return diffs

def check_arg_compatibility(args: argparse.Namespace):
    """
    Check if some arguments are incompatible with each other.

    :param args: Arguments as returned by argparse.
    """
    check_condition(args.optimized_metric == C.BLEU or args.optimized_metric in args.metrics,
                    "Must optimize either BLEU or one of tracked metrics (--metrics)")

    if args.encoder == C.TRANSFORMER_TYPE:
        check_condition(args.transformer_model_size[0] == args.num_embed[0],
                        "Source embedding size must match transformer model size: %s vs. %s"
                        % (args.transformer_model_size, args.num_embed[0]))

        total_source_factor_size = sum(args.source_factors_num_embed)
        if total_source_factor_size > 0:
            adjusted_transformer_encoder_model_size = args.num_embed[0] + total_source_factor_size
            check_condition(adjusted_transformer_encoder_model_size % 2 == 0 and
                            adjusted_transformer_encoder_model_size % args.transformer_attention_heads[0] == 0,
                            "Sum of source factor sizes, i.e. num-embed plus source-factors-num-embed, (%d) "
                            "has to be even and a multiple of encoder attention heads (%d)" % (
                                adjusted_transformer_encoder_model_size, args.transformer_attention_heads[0]))

    if args.decoder == C.TRANSFORMER_TYPE:
        check_condition(args.transformer_model_size[1] == args.num_embed[1],
                        "Target embedding size must match transformer model size: %s vs. %s"
                        % (args.transformer_model_size, args.num_embed[1]))

    if args.lhuc is not None:
        # Actually this check is a bit too strict
        check_condition(args.encoder != C.CONVOLUTION_TYPE or args.decoder != C.CONVOLUTION_TYPE,
                        "LHUC is not supported for convolutional models yet.")
        check_condition(args.decoder != C.TRANSFORMER_TYPE or C.LHUC_STATE_INIT not in args.lhuc,
                        "The %s options only applies to RNN models" % C.LHUC_STATE_INIT)

def check_resume(args: argparse.Namespace, output_folder: str) -> bool:
    """
    Check if we should resume a broken training run.

    :param args: Arguments as returned by argparse.
    :param output_folder: Main output folder for the model.
    :return: Flag signaling if we are resuming training and the directory with
        the training status.
    """
    resume_training = False
    training_state_dir = os.path.join(output_folder, C.TRAINING_STATE_DIRNAME)
    if os.path.exists(output_folder):
        if args.overwrite_output:
            logger.info("Removing existing output folder %s.", output_folder)
            shutil.rmtree(output_folder)
            os.makedirs(output_folder)
        elif os.path.exists(training_state_dir):
            old_args = vars(arguments.load_args(os.path.join(output_folder, C.ARGS_STATE_NAME)))
            arg_diffs = _dict_difference(vars(args), old_args) | _dict_difference(old_args, vars(args))
            # Remove args that may differ without affecting the training.
            arg_diffs -= set(C.ARGS_MAY_DIFFER)
            # allow different device-ids provided their total count is the same
            if 'device_ids' in arg_diffs and len(old_args['device_ids']) == len(vars(args)['device_ids']):
                arg_diffs.discard('device_ids')
            if not arg_diffs:
                resume_training = True
            else:
                # We do not have the logger yet
                logger.error("Mismatch in arguments for training continuation.")
                logger.error("Differing arguments: %s.", ", ".join(arg_diffs))
                sys.exit(1)
        elif os.path.exists(os.path.join(output_folder, C.PARAMS_BEST_NAME)):
            logger.error("Refusing to overwrite model folder %s as it seems to contain a trained model.", output_folder)
            sys.exit(1)
        else:
            logger.info("The output folder %s already exists, but no training state or parameter file was found. "
                        "Will start training from scratch.", output_folder)
    else:
        os.makedirs(output_folder)

    return resume_training

def determine_context(args: argparse.Namespace, exit_stack: ExitStack) -> List[mx.Context]:
    """
    Determine the context we should run on (CPU or GPU).

    :param args: Arguments as returned by argparse.
    :param exit_stack: An ExitStack from contextlib.
    :return: A list with the context(s) to run on.
    """
    if args.use_cpu:
        logger.info("Training Device: CPU")
        context = [mx.cpu()]
    else:
        num_gpus = utils.get_num_gpus()
        check_condition(num_gpus >= 1,
                        "No GPUs found, consider running on the CPU with --use-cpu "
                        "(note: check depends on nvidia-smi and this could also mean that the nvidia-smi "
                        "binary isn't on the path).")
        if args.disable_device_locking:
            context = utils.expand_requested_device_ids(args.device_ids)
        else:
            context = exit_stack.enter_context(utils.acquire_gpus(args.device_ids, lock_dir=args.lock_dir))
        if args.batch_type == C.BATCH_TYPE_SENTENCE:
            check_condition(args.batch_size % len(context) == 0, "When using multiple devices the batch size must be "
                                                                 "divisible by the number of devices. Choose a batch "
                                                                 "size that is a multiple of %d." % len(context))
        logger.info("Training Device(s): GPU %s", context)
        context = [mx.gpu(gpu_id) for gpu_id in context]
    return context

def create_checkpoint_decoder(args: argparse.Namespace,
                              exit_stack: ExitStack,
                              train_context: List[mx.Context]) -> Optional[checkpoint_decoder.CheckpointDecoder]:
    """
    Returns a checkpoint decoder or None.

    :param args: Arguments as returned by argparse.
    :param exit_stack: An ExitStack from contextlib.
    :param train_context: Context for training.
    :return: A CheckpointDecoder if --decode-and-evaluate != 0, else None.
    """
    sample_size = args.decode_and_evaluate
    if args.optimized_metric == C.BLEU and sample_size == 0:
        logger.info("You chose BLEU as the optimized metric, will turn on BLEU monitoring during training. "
                    "To control how many validation sentences are used for calculating bleu use "
                    "the --decode-and-evaluate argument.")
        sample_size = -1

    if sample_size == 0:
        return None

    if args.use_cpu or args.decode_and_evaluate_use_cpu:
        context = mx.cpu()
    elif args.decode_and_evaluate_device_id is not None:
        # decode device is defined from the commandline
        num_gpus = utils.get_num_gpus()
        check_condition(num_gpus >= 1,
                        "No GPUs found, consider running on the CPU with --use-cpu "
                        "(note: check depends on nvidia-smi and this could also mean that the nvidia-smi "
                        "binary isn't on the path).")

        if args.disable_device_locking:
            context = utils.expand_requested_device_ids([args.decode_and_evaluate_device_id])
        else:
            context = exit_stack.enter_context(utils.acquire_gpus([args.decode_and_evaluate_device_id],
                                                                  lock_dir=args.lock_dir))
        context = mx.gpu(context[0])

    else:
        # default decode context is the last training device
        context = train_context[-1]

    return checkpoint_decoder.CheckpointDecoder(context=context,
                                                inputs=[args.validation_source] + args.validation_source_factors,
                                                references=args.validation_target,
                                                model=args.output,
                                                sample_size=sample_size)

def use_shared_vocab(args: argparse.Namespace) -> bool:
    """
    True if arguments entail a shared source and target vocabulary.

    :param: args: Arguments as returned by argparse.
    """
    weight_tying = args.weight_tying
    weight_tying_type = args.weight_tying_type
    shared_vocab = args.shared_vocab
    if weight_tying and C.WEIGHT_TYING_SRC in weight_tying_type and C.WEIGHT_TYING_TRG in weight_tying_type:
        if not shared_vocab:
            logger.info("A shared source/target vocabulary will be used as weight tying source/target weight tying "
                        "is enabled")
        shared_vocab = True
    return shared_vocab

def create_data_iters_and_vocabs(args: argparse.Namespace,
                                 max_seq_len_source: int,
                                 max_seq_len_target: int,
                                 shared_vocab: bool,
                                 resume_training: bool,
                                 output_folder: str) -> Tuple['data_io.BaseParallelSampleIter',
                                                              'data_io.BaseParallelSampleIter',
                                                              'data_io.DataConfig',
                                                              List[vocab.Vocab], vocab.Vocab]:
    """
    Create the data iterators and the vocabularies.

    :param args: Arguments as returned by argparse.
    :param max_seq_len_source: Source maximum sequence length.
    :param max_seq_len_target: Target maximum sequence length.
    :param shared_vocab: Whether to create a shared vocabulary.
    :param resume_training: Whether to resume training.
    :param output_folder: Output folder.
    :return: The data iterators (train, validation, config_data) as well as the source and target vocabularies.
    """
    num_words_source, num_words_target = args.num_words
    word_min_count_source, word_min_count_target = args.word_min_count
    batch_num_devices = 1 if args.use_cpu else sum(-di if di < 0 else 1 for di in args.device_ids)
    batch_by_words = args.batch_type == C.BATCH_TYPE_WORD

    validation_sources = [args.validation_source] + args.validation_source_factors
    validation_sources = [str(os.path.abspath(source)) for source in validation_sources]

    either_raw_or_prepared_error_msg = "Either specify a raw training corpus with %s and %s or a preprocessed corpus " \
                                       "with %s." % (C.TRAINING_ARG_SOURCE,
                                                     C.TRAINING_ARG_TARGET,
                                                     C.TRAINING_ARG_PREPARED_DATA)
    if args.prepared_data is not None:
        utils.check_condition(args.source is None and args.target is None, either_raw_or_prepared_error_msg)
        if not resume_training:
            utils.check_condition(args.source_vocab is None and args.target_vocab is None,
                                  "You are using a prepared data folder, which is tied to a vocabulary. "
                                  "To change it you need to rerun data preparation with a different vocabulary.")
        train_iter, validation_iter, data_config, source_vocabs, target_vocab = data_io.get_prepared_data_iters(
            prepared_data_dir=args.prepared_data,
            validation_sources=validation_sources,
            validation_target=str(os.path.abspath(args.validation_target)),
            shared_vocab=shared_vocab,
            batch_size=args.batch_size,
            batch_by_words=batch_by_words,
            batch_num_devices=batch_num_devices,
            fill_up=args.fill_up)

        check_condition(len(source_vocabs) == len(args.source_factors_num_embed) + 1,
                        "Data was prepared with %d source factors, but only provided %d source factor dimensions." % (
                            len(source_vocabs), len(args.source_factors_num_embed) + 1))

        if resume_training:
            # resuming training. Making sure the vocabs in the model and in the prepared data match up
            model_source_vocabs = vocab.load_source_vocabs(output_folder)
            for i, (v, mv) in enumerate(zip(source_vocabs, model_source_vocabs)):
                utils.check_condition(vocab.are_identical(v, mv),
                                      "Prepared data and resumed model source vocab %d do not match." % i)
            model_target_vocab = vocab.load_target_vocab(output_folder)
            utils.check_condition(vocab.are_identical(target_vocab, model_target_vocab),
                                  "Prepared data and resumed model target vocabs do not match.")

            check_condition(len(args.source_factors) == len(args.validation_source_factors),
                            'Training and validation data must have the same number of factors: %d vs. %d.' % (
                                len(args.source_factors), len(args.validation_source_factors)))

        return train_iter, validation_iter, data_config, source_vocabs, target_vocab

    else:
        utils.check_condition(args.prepared_data is None and args.source is not None and args.target is not None,
                              either_raw_or_prepared_error_msg)

        if resume_training:
            # Load the existing vocabs created when starting the training run.
            source_vocabs = vocab.load_source_vocabs(output_folder)
            target_vocab = vocab.load_target_vocab(output_folder)

            # Recover the vocabulary path from the data info file:
            data_info = cast(data_io.DataInfo, Config.load(os.path.join(output_folder, C.DATA_INFO)))
            source_vocab_paths = data_info.source_vocabs
            target_vocab_path = data_info.target_vocab

        else:
            # Load or create vocabs
            source_vocab_paths = [args.source_vocab] + [None] * len(args.source_factors)
            target_vocab_path = args.target_vocab
            source_vocabs, target_vocab = vocab.load_or_create_vocabs(
                source_paths=[args.source] + args.source_factors,
                target_path=args.target,
                source_vocab_paths=source_vocab_paths,
                target_vocab_path=target_vocab_path,
                shared_vocab=shared_vocab,
                num_words_source=num_words_source,
                num_words_target=num_words_target,
                word_min_count_source=word_min_count_source,
                word_min_count_target=word_min_count_target)

        check_condition(len(args.source_factors) == len(args.source_factors_num_embed),
                        "Number of source factor data (%d) differs from provided source factor dimensions (%d)" % (
                            len(args.source_factors), len(args.source_factors_num_embed)))

        sources = [args.source] + args.source_factors
        sources = [str(os.path.abspath(source)) for source in sources]

        train_iter, validation_iter, config_data, data_info = data_io.get_training_data_iters(
            sources=sources,
            target=os.path.abspath(args.target),
            validation_sources=validation_sources,
            validation_target=os.path.abspath(args.validation_target),
            source_vocabs=source_vocabs,
            target_vocab=target_vocab,
            source_vocab_paths=source_vocab_paths,
            target_vocab_path=target_vocab_path,
            shared_vocab=shared_vocab,
            batch_size=args.batch_size,
            batch_by_words=batch_by_words,
            batch_num_devices=batch_num_devices,
            fill_up=args.fill_up,
            max_seq_len_source=max_seq_len_source,
            max_seq_len_target=max_seq_len_target,
            bucketing=not args.no_bucketing,
            bucket_width=args.bucket_width)

        data_info_fname = os.path.join(output_folder, C.DATA_INFO)
        logger.info("Writing data config to '%s'", data_info_fname)
        data_info.save(data_info_fname)

        return train_iter, validation_iter, config_data, source_vocabs, target_vocab

def create_encoder_config(args: argparse.Namespace,
                          max_seq_len_source: int,
                          max_seq_len_target: int,
                          config_conv: Optional[encoder.ConvolutionalEmbeddingConfig]) -> Tuple[encoder.EncoderConfig,
                                                                                int]:
    """
    Create the encoder config.

    :param args: Arguments as returned by argparse.
    :param max_seq_len_source: Maximum source sequence length.
    :param max_seq_len_target: Maximum target sequence length.
    :param config_conv: The config for the convolutional encoder (optional).
    :return: The encoder config and the number of hidden units of the encoder.
    """
    encoder_num_layers, _ = args.num_layers
    num_embed_source, _ = args.num_embed
    config_encoder = None  # type: Optional[Config]

    if args.encoder in (C.TRANSFORMER_TYPE, C.TRANSFORMER_WITH_CONV_EMBED_TYPE):
        encoder_transformer_preprocess, _ = args.transformer_preprocess
        encoder_transformer_postprocess, _ = args.transformer_postprocess
        encoder_transformer_model_size = args.transformer_model_size[0]

        total_source_factor_size = sum(args.source_factors_num_embed)
        if total_source_factor_size > 0:
            logger.info("Encoder transformer-model-size adjusted to account source factor embeddings: %d -> %d" % (
                encoder_transformer_model_size, num_embed_source + total_source_factor_size))
            encoder_transformer_model_size = num_embed_source + total_source_factor_size
        config_encoder = transformer.TransformerConfig(
            model_size=encoder_transformer_model_size,
            attention_heads=args.transformer_attention_heads[0],
            feed_forward_num_hidden=args.transformer_feed_forward_num_hidden[0],
            act_type=args.transformer_activation_type,
            num_layers=encoder_num_layers,
            dropout_attention=args.transformer_dropout_attention,
            dropout_act=args.transformer_dropout_act,
            dropout_prepost=args.transformer_dropout_prepost,
            positional_embedding_type=args.transformer_positional_embedding_type,
            preprocess_sequence=encoder_transformer_preprocess,
            postprocess_sequence=encoder_transformer_postprocess,
            max_seq_len_source=max_seq_len_source,
            max_seq_len_target=max_seq_len_target,
            conv_config=config_conv,
            lhuc=args.lhuc is not None and (C.LHUC_ENCODER in args.lhuc or C.LHUC_ALL in args.lhuc))
        encoder_num_hidden = encoder_transformer_model_size
    elif args.encoder == C.CONVOLUTION_TYPE:
        cnn_kernel_width_encoder, _ = args.cnn_kernel_width
        cnn_config = convolution.ConvolutionConfig(kernel_width=cnn_kernel_width_encoder,
                                                   num_hidden=args.cnn_num_hidden,
                                                   act_type=args.cnn_activation_type,
                                                   weight_normalization=args.weight_normalization)
        cnn_num_embed = num_embed_source + sum(args.source_factors_num_embed)
        config_encoder = encoder.ConvolutionalEncoderConfig(num_embed=cnn_num_embed,
                                                            max_seq_len_source=max_seq_len_source,
                                                            cnn_config=cnn_config,
                                                            num_layers=encoder_num_layers,
                                                            positional_embedding_type=args.cnn_positional_embedding_type)

        encoder_num_hidden = args.cnn_num_hidden
    else:
        encoder_rnn_dropout_inputs, _ = args.rnn_dropout_inputs
        encoder_rnn_dropout_states, _ = args.rnn_dropout_states
        encoder_rnn_dropout_recurrent, _ = args.rnn_dropout_recurrent
        config_encoder = encoder.RecurrentEncoderConfig(
            rnn_config=rnn.RNNConfig(cell_type=args.rnn_cell_type,
                                     num_hidden=args.rnn_num_hidden,
                                     num_layers=encoder_num_layers,
                                     dropout_inputs=encoder_rnn_dropout_inputs,
                                     dropout_states=encoder_rnn_dropout_states,
                                     dropout_recurrent=encoder_rnn_dropout_recurrent,
                                     residual=args.rnn_residual_connections,
                                     first_residual_layer=args.rnn_first_residual_layer,
                                     forget_bias=args.rnn_forget_bias,
                                     lhuc=args.lhuc is not None and (C.LHUC_ENCODER in args.lhuc or C.LHUC_ALL in args.lhuc)),
            conv_config=config_conv,
            reverse_input=args.rnn_encoder_reverse_input)
        encoder_num_hidden = args.rnn_num_hidden

    return config_encoder, encoder_num_hidden

def create_decoder_config(args: argparse.Namespace, encoder_num_hidden: int,
                          max_seq_len_source: int, max_seq_len_target: int) -> decoder.DecoderConfig:
    """
    Create the config for the decoder.

    :param args: Arguments as returned by argparse.
    :param encoder_num_hidden: Number of hidden units of the Encoder.
    :param max_seq_len_source: Maximum source sequence length.
    :param max_seq_len_target: Maximum target sequence length.
    :return: The config for the decoder.
    """
    _, decoder_num_layers = args.num_layers
    _, num_embed_target = args.num_embed

    config_decoder = None  # type: Optional[Config]

    if args.decoder == C.TRANSFORMER_TYPE:
        _, decoder_transformer_preprocess = args.transformer_preprocess
        _, decoder_transformer_postprocess = args.transformer_postprocess
        config_decoder = transformer.TransformerConfig(
            model_size=args.transformer_model_size[1],
            attention_heads=args.transformer_attention_heads[1],
            feed_forward_num_hidden=args.transformer_feed_forward_num_hidden[1],
            act_type=args.transformer_activation_type,
            num_layers=decoder_num_layers,
            dropout_attention=args.transformer_dropout_attention,
            dropout_act=args.transformer_dropout_act,
            dropout_prepost=args.transformer_dropout_prepost,
            positional_embedding_type=args.transformer_positional_embedding_type,
            preprocess_sequence=decoder_transformer_preprocess,
            postprocess_sequence=decoder_transformer_postprocess,
            max_seq_len_source=max_seq_len_source,
            max_seq_len_target=max_seq_len_target,
            conv_config=None,
            lhuc=args.lhuc is not None and (C.LHUC_DECODER in args.lhuc or C.LHUC_ALL in args.lhuc))

    elif args.decoder == C.CONVOLUTION_TYPE:
        _, cnn_kernel_width_decoder = args.cnn_kernel_width
        convolution_config = convolution.ConvolutionConfig(kernel_width=cnn_kernel_width_decoder,
                                                           num_hidden=args.cnn_num_hidden,
                                                           act_type=args.cnn_activation_type,
                                                           weight_normalization=args.weight_normalization)
        config_decoder = decoder.ConvolutionalDecoderConfig(cnn_config=convolution_config,
                                                            max_seq_len_target=max_seq_len_target,
                                                            num_embed=num_embed_target,
                                                            encoder_num_hidden=encoder_num_hidden,
                                                            num_layers=decoder_num_layers,
                                                            positional_embedding_type=args.cnn_positional_embedding_type,
                                                            project_qkv=args.cnn_project_qkv,
                                                            hidden_dropout=args.cnn_hidden_dropout)

    else:
        rnn_attention_num_hidden = args.rnn_num_hidden if args.rnn_attention_num_hidden is None else args.rnn_attention_num_hidden
        config_coverage = None
        if args.rnn_attention_type == C.ATT_COV:
            config_coverage = coverage.CoverageConfig(type=args.rnn_attention_coverage_type,
                                                      num_hidden=args.rnn_attention_coverage_num_hidden,
                                                      layer_normalization=args.layer_normalization)
        config_attention = rnn_attention.AttentionConfig(type=args.rnn_attention_type,
                                                         num_hidden=rnn_attention_num_hidden,
                                                         input_previous_word=args.rnn_attention_use_prev_word,
                                                         source_num_hidden=encoder_num_hidden,
                                                         query_num_hidden=args.rnn_num_hidden,
                                                         layer_normalization=args.layer_normalization,
                                                         config_coverage=config_coverage,
                                                         num_heads=args.rnn_attention_mhdot_heads,
                                                         is_scaled=args.rnn_scale_dot_attention)

        _, decoder_rnn_dropout_inputs = args.rnn_dropout_inputs
        _, decoder_rnn_dropout_states = args.rnn_dropout_states
        _, decoder_rnn_dropout_recurrent = args.rnn_dropout_recurrent

        config_decoder = decoder.RecurrentDecoderConfig(
            max_seq_len_source=max_seq_len_source,
            rnn_config=rnn.RNNConfig(cell_type=args.rnn_cell_type,
                                     num_hidden=args.rnn_num_hidden,
                                     num_layers=decoder_num_layers,
                                     dropout_inputs=decoder_rnn_dropout_inputs,
                                     dropout_states=decoder_rnn_dropout_states,
                                     dropout_recurrent=decoder_rnn_dropout_recurrent,
                                     residual=args.rnn_residual_connections,
                                     first_residual_layer=args.rnn_first_residual_layer,
                                     forget_bias=args.rnn_forget_bias,
                                     lhuc=args.lhuc is not None and (C.LHUC_DECODER in args.lhuc or C.LHUC_ALL in args.lhuc)),
            attention_config=config_attention,
            hidden_dropout=args.rnn_decoder_hidden_dropout,
            state_init=args.rnn_decoder_state_init,
            context_gating=args.rnn_context_gating,
            layer_normalization=args.layer_normalization,
            attention_in_upper_layers=args.rnn_attention_in_upper_layers,
            state_init_lhuc=args.lhuc is not None and (C.LHUC_STATE_INIT in args.lhuc or C.LHUC_ALL in args.lhuc),
            enc_last_hidden_concat_to_embedding=args.rnn_enc_last_hidden_concat_to_embedding)

    return config_decoder

def check_encoder_decoder_args(args) -> None:
    """
    Check possible encoder-decoder argument conflicts.

    :param args: Arguments as returned by argparse.
    """
    encoder_embed_dropout, decoder_embed_dropout = args.embed_dropout
    encoder_rnn_dropout_inputs, decoder_rnn_dropout_inputs = args.rnn_dropout_inputs
    encoder_rnn_dropout_states, decoder_rnn_dropout_states = args.rnn_dropout_states
    if encoder_embed_dropout > 0 and encoder_rnn_dropout_inputs > 0:
        logger.warning("Setting encoder RNN AND source embedding dropout > 0 leads to "
                       "two dropout layers on top of each other.")
    if decoder_embed_dropout > 0 and decoder_rnn_dropout_inputs > 0:
        logger.warning("Setting encoder RNN AND source embedding dropout > 0 leads to "
                       "two dropout layers on top of each other.")
    encoder_rnn_dropout_recurrent, decoder_rnn_dropout_recurrent = args.rnn_dropout_recurrent
    if encoder_rnn_dropout_recurrent > 0 or decoder_rnn_dropout_recurrent > 0:
        check_condition(args.rnn_cell_type == C.LSTM_TYPE,
                        "Recurrent dropout without memory loss only supported for LSTMs right now.")

def create_model_config(args: argparse.Namespace,
                        source_vocab_sizes: List[int],
                        target_vocab_size: int,
                        max_seq_len_source: int,
                        max_seq_len_target: int,
                        config_data: data_io.DataConfig) -> model.ModelConfig:
    """
    Create a ModelConfig from the argument given in the command line.

    :param args: Arguments as returned by argparse.
    :param source_vocab_sizes: The size of the source vocabulary (and source factors).
    :param target_vocab_size: The size of the target vocabulary.
    :param max_seq_len_source: Maximum source sequence length.
    :param max_seq_len_target: Maximum target sequence length.
    :param config_data: Data config.
    :return: The model configuration.
    """
    num_embed_source, num_embed_target = args.num_embed
    embed_dropout_source, embed_dropout_target = args.embed_dropout
    source_vocab_size, *source_factor_vocab_sizes = source_vocab_sizes

    check_encoder_decoder_args(args)

    config_conv = None
    if args.encoder == C.RNN_WITH_CONV_EMBED_NAME:
        config_conv = encoder.ConvolutionalEmbeddingConfig(num_embed=num_embed_source,
                                                           max_filter_width=args.conv_embed_max_filter_width,
                                                           num_filters=args.conv_embed_num_filters,
                                                           pool_stride=args.conv_embed_pool_stride,
                                                           num_highway_layers=args.conv_embed_num_highway_layers,
                                                           dropout=args.conv_embed_dropout)
    if args.encoder == C.TRANSFORMER_WITH_CONV_EMBED_TYPE:
        config_conv = encoder.ConvolutionalEmbeddingConfig(num_embed=num_embed_source,
                                                           output_dim=num_embed_source,
                                                           max_filter_width=args.conv_embed_max_filter_width,
                                                           num_filters=args.conv_embed_num_filters,
                                                           pool_stride=args.conv_embed_pool_stride,
                                                           num_highway_layers=args.conv_embed_num_highway_layers,
                                                           dropout=args.conv_embed_dropout)

    config_encoder, encoder_num_hidden = create_encoder_config(args, max_seq_len_source, max_seq_len_target,
                                                               config_conv)
    config_decoder = create_decoder_config(args, encoder_num_hidden, max_seq_len_source, max_seq_len_target)

    source_factor_configs = None
    if len(source_vocab_sizes) > 1:
        source_factor_configs = [encoder.FactorConfig(size, dim) for size, dim in zip(source_factor_vocab_sizes,
                                                                                args.source_factors_num_embed)]

    config_embed_source = encoder.EmbeddingConfig(vocab_size=source_vocab_size,
                                                  num_embed=num_embed_source,
                                                  dropout=embed_dropout_source,
                                                  factor_configs=source_factor_configs)

    config_embed_target = encoder.EmbeddingConfig(vocab_size=target_vocab_size,
                                                  num_embed=num_embed_target,
                                                  dropout=embed_dropout_target)

    config_loss = loss.LossConfig(name=args.loss,
                                  vocab_size=target_vocab_size,
                                  normalization_type=args.loss_normalization_type,
                                  label_smoothing=args.label_smoothing)

    model_config = model.ModelConfig(config_data=config_data,
                                     vocab_source_size=source_vocab_size,
                                     vocab_target_size=target_vocab_size,
                                     config_embed_source=config_embed_source,
                                     config_embed_target=config_embed_target,
                                     config_encoder=config_encoder,
                                     config_decoder=config_decoder,
                                     config_loss=config_loss,
                                     weight_tying=args.weight_tying,
                                     weight_tying_type=args.weight_tying_type if args.weight_tying else None,
                                     weight_normalization=args.weight_normalization,
                                     lhuc=args.lhuc is not None)
    return model_config

def create_training_model(config: model.ModelConfig,
                          context: List[mx.Context],
                          output_dir: str,
                          train_iter: data_io.BaseParallelSampleIter,
                          args: argparse.Namespace) -> training.TrainingModel:
    """
    Create a training model and load the parameters from disk if needed.

    :param config: The configuration for the model.
    :param context: The context(s) to run on.
    :param output_dir: Output folder.
    :param train_iter: The training data iterator.
    :param args: Arguments as returned by argparse.
    :return: The training model.
    """
    training_model = training.TrainingModel(config=config,
                                            context=context,
                                            output_dir=output_dir,
                                            provide_data=train_iter.provide_data,
                                            provide_label=train_iter.provide_label,
                                            default_bucket_key=train_iter.default_bucket_key,
                                            bucketing=not args.no_bucketing,
                                            gradient_compression_params=gradient_compression_params(args),
                                            fixed_param_names=args.fixed_param_names)

    return training_model

def gradient_compression_params(args: argparse.Namespace) -> Optional[Dict[str, Any]]:
    """
    :param args: Arguments as returned by argparse.
    :return: Gradient compression parameters or None.
    """
    if args.gradient_compression_type is None:
        return None
    else:
        return {'type': args.gradient_compression_type, 'threshold': args.gradient_compression_threshold}

def create_optimizer_config(args: argparse.Namespace, source_vocab_sizes: List[int],
                            extra_initializers: List[Tuple[str, mx.initializer.Initializer]] = None) -> OptimizerConfig:
    """
    Returns an OptimizerConfig.

    :param args: Arguments as returned by argparse.
    :param source_vocab_sizes: Source vocabulary sizes.
    :param extra_initializers: extra initializer to pass to `get_initializer`.
    :return: The optimizer type and its parameters as well as the kvstore.
    """
    optimizer_params = {'wd': args.weight_decay,
                        "learning_rate": args.initial_learning_rate}

    gradient_clipping_threshold = none_if_negative(args.gradient_clipping_threshold)
    if gradient_clipping_threshold is None:
        logger.info("Gradient clipping threshold set to negative value. Will not perform gradient clipping.")
        gradient_clipping_type = C.GRADIENT_CLIPPING_TYPE_NONE
    else:
        gradient_clipping_type = args.gradient_clipping_type

    # Note: for 'abs' we use the implementation inside of MXNet's optimizer and 'norm_*' we implement ourselves
    # inside the TrainingModel.
    if gradient_clipping_threshold is not None and gradient_clipping_type == C.GRADIENT_CLIPPING_TYPE_ABS:
        optimizer_params["clip_gradient"] = gradient_clipping_threshold
    if args.momentum is not None:
        optimizer_params["momentum"] = args.momentum
    if args.loss_normalization_type == C.LOSS_NORM_VALID:
        # When we normalize by the number of non-PAD symbols in a batch we need to disable rescale_grad.
        optimizer_params["rescale_grad"] = 1.0
    elif args.loss_normalization_type == C.LOSS_NORM_BATCH:
        # Making MXNet module API's default scaling factor explicit
        optimizer_params["rescale_grad"] = 1.0 / args.batch_size
    # Manually specified params
    if args.optimizer_params:
        optimizer_params.update(args.optimizer_params)

    weight_init = initializer.get_initializer(default_init_type=args.weight_init,
                                              default_init_scale=args.weight_init_scale,
                                              default_init_xavier_rand_type=args.weight_init_xavier_rand_type,
                                              default_init_xavier_factor_type=args.weight_init_xavier_factor_type,
                                              embed_init_type=args.embed_weight_init,
                                              embed_init_sigma=source_vocab_sizes[0] ** -0.5,
                                              rnn_init_type=args.rnn_h2h_init,
                                              extra_initializers=extra_initializers)

    lr_sched = lr_scheduler.get_lr_scheduler(args.learning_rate_scheduler_type,
                                             args.checkpoint_frequency,
                                             none_if_negative(args.learning_rate_half_life),
                                             args.learning_rate_reduce_factor,
                                             args.learning_rate_reduce_num_not_improved,
                                             args.learning_rate_schedule,
                                             args.learning_rate_warmup)

    config = OptimizerConfig(name=args.optimizer,
                             params=optimizer_params,
                             kvstore=args.kvstore,
                             initializer=weight_init,
                             gradient_clipping_type=gradient_clipping_type,
                             gradient_clipping_threshold=gradient_clipping_threshold)
    config.set_lr_scheduler(lr_sched)
    logger.info("Optimizer: %s", config)
    logger.info("Gradient Compression: %s", gradient_compression_params(args))
    return config

def main():
    params = arguments.ConfigArgumentParser(description='Train Sockeye sequence-to-sequence models.')
    arguments.add_train_cli_args(params)
    args = params.parse_args()
    train(args)

def train(args: argparse.Namespace):
    if args.dry_run:
        # Modify arguments so that we write to a temporary directory and
        # perform 0 training iterations
        temp_dir = tempfile.TemporaryDirectory()  # Will be automatically removed
        args.output = temp_dir.name
        args.max_updates = 0

    utils.seedRNGs(args.seed)

    check_arg_compatibility(args)
    output_folder = os.path.abspath(args.output)
    resume_training = check_resume(args, output_folder)

    global logger
    logger = setup_main_logger(__name__,
                               file_logging=True,
                               console=not args.quiet, path=os.path.join(output_folder, C.LOG_NAME))
    utils.log_basic_info(args)
    arguments.save_args(args, os.path.join(output_folder, C.ARGS_STATE_NAME))

    max_seq_len_source, max_seq_len_target = args.max_seq_len
    # The maximum length is the length before we add the BOS/EOS symbols
    max_seq_len_source = max_seq_len_source + C.SPACE_FOR_XOS
    max_seq_len_target = max_seq_len_target + C.SPACE_FOR_XOS
    logger.info("Adjusting maximum length to reserve space for a BOS/EOS marker. New maximum length: (%d, %d)",
                max_seq_len_source, max_seq_len_target)

    with ExitStack() as exit_stack:
        context = determine_context(args, exit_stack)

        train_iter, eval_iter, config_data, source_vocabs, target_vocab = create_data_iters_and_vocabs(
            args=args,
            max_seq_len_source=max_seq_len_source,
            max_seq_len_target=max_seq_len_target,
            shared_vocab=use_shared_vocab(args),
            resume_training=resume_training,
            output_folder=output_folder)
        max_seq_len_source = config_data.max_seq_len_source
        max_seq_len_target = config_data.max_seq_len_target

        # Dump the vocabularies if we're just starting up
        if not resume_training:
            vocab.save_source_vocabs(source_vocabs, output_folder)
            vocab.save_target_vocab(target_vocab, output_folder)

        source_vocab_sizes = [len(v) for v in source_vocabs]
        target_vocab_size = len(target_vocab)
        logger.info('Vocabulary sizes: source=[%s] target=%d',
                    '|'.join([str(size) for size in source_vocab_sizes]),
                    target_vocab_size)

        model_config = create_model_config(args=args,
                                           source_vocab_sizes=source_vocab_sizes, target_vocab_size=target_vocab_size,
                                           max_seq_len_source=max_seq_len_source, max_seq_len_target=max_seq_len_target,
                                           config_data=config_data)
        model_config.freeze()

        training_model = create_training_model(config=model_config,
                                               context=context,
                                               output_dir=output_folder,
                                               train_iter=train_iter,
                                               args=args)

        # Handle options that override training settings
        min_updates = args.min_updates
        max_updates = args.max_updates
        min_samples = args.min_samples
        max_samples = args.max_samples
        max_num_checkpoint_not_improved = args.max_num_checkpoint_not_improved
        min_epochs = args.min_num_epochs
        max_epochs = args.max_num_epochs
        if min_epochs is not None and max_epochs is not None:
            check_condition(min_epochs <= max_epochs,
                            "Minimum number of epochs must be smaller than maximum number of epochs")
        # Fixed training schedule always runs for a set number of updates
        if args.learning_rate_schedule:
            min_updates = None
            max_updates = sum(num_updates for (_, num_updates) in args.learning_rate_schedule)
            max_num_checkpoint_not_improved = -1
            min_samples = None
            max_samples = None
            min_epochs = None
            max_epochs = None

        trainer = training.EarlyStoppingTrainer(model=training_model,
                                                optimizer_config=create_optimizer_config(args, source_vocab_sizes),
                                                max_params_files_to_keep=args.keep_last_params,
                                                source_vocabs=source_vocabs,
                                                target_vocab=target_vocab)

        trainer.fit(train_iter=train_iter,
                    validation_iter=eval_iter,
                    early_stopping_metric=args.optimized_metric,
                    metrics=args.metrics,
                    checkpoint_frequency=args.checkpoint_frequency,
                    max_num_not_improved=max_num_checkpoint_not_improved,
                    min_samples=min_samples,
                    max_samples=max_samples,
                    min_updates=min_updates,
                    max_updates=max_updates,
                    min_epochs=min_epochs,
                    max_epochs=max_epochs,
                    lr_decay_param_reset=args.learning_rate_decay_param_reset,
                    lr_decay_opt_states_reset=args.learning_rate_decay_optimizer_states_reset,
                    decoder=create_checkpoint_decoder(args, exit_stack, context),
                    mxmonitor_pattern=args.monitor_pattern,
                    mxmonitor_stat_func=args.monitor_stat_func,
                    allow_missing_parameters=args.allow_missing_params or model_config.lhuc,
                    existing_parameters=args.params)

if __name__ == "__main__":
    main()

redpajama_set_name: RedPajamaGithub


text:
CFP 9th Workshop on Answer Set Programming and Other Computing Paradigms
Jun 27, 2016 • Amelia Harrison CFP Deadline ASP
LAST CALL FOR PAPERS
ASPOCP 2016
9th Workshop on Answer Set Programming and Other Computing Paradigms
https://sites.google.com/site/aspocp2016
Affiliated with the 32nd International Conference on Logic Programming
Since its introduction in the late 1980s, Answer Set Programming (ASP) has been widely applied to various knowledge-intensive tasks and combinatorial search problems. ASP was found to be closely related to SAT, which led to a new method of computing answer sets using SAT solvers and techniques adapted from SAT. This has been a much studied relationship, and is currently extended towards satisfiability modulo theories (SMT). The relationship of ASP to other computing paradigms, such as constraint satisfaction, quantified Boolean formulas (QBF), Constraint Logic Programming (CLP), first-order logic (FOL), and FO(ID) is also the subject of active research. Consequently, new methods of computing answer sets are being developed based on relationships to these formalisms.
Furthermore, the practical applications of ASP also foster work on multi-paradigm problem-solving, and in particular language and solver integration. The most prominent examples in this area currently are the integration of ASP with description logics (in the realm of the Semantic Web) and constraint satisfaction (which recently led to the Constraint Answer Set Programming (CASP) research direction).
A large body of general results regarding ASP is available and several efficient ASP solvers have been implemented. However, there are still significant challenges in applying ASP to real life applications, and more interest in relating ASP to other computing paradigms is emerging. This workshop will provide opportunities for researchers to identify these challenges and to exchange ideas for overcoming them.
Topics of interests include (but are not limited to):
ASP and classical logic formalisms (SAT/FOL/QBF/SMT/DL).
ASP and constraint programming.
ASP and other logic programming paradigms, e.g., FO(ID).
ASP and other nonmonotonic languages, e.g., action languages.
ASP and external means of computation.
ASP and probabilistic reasoning.
ASP and knowledge compilation.
ASP and machine learning.
New methods of computing answer sets using algorithms or systems of
other paradigms.
Language extensions to ASP.
ASP and multi-agent systems.
ASP and multi-context systems.
Modularity and ASP.
ASP and argumentation.
Multi-paradigm problem solving involving ASP.
Evaluation and comparison of ASP to other paradigms.
ASP and related paradigms in applications.
Hybridizing ASP with procedural approaches.
Enhanced grounding or beyond grounding.
Papers must describe original research and should not exceed 15 pages in the Springer LNCS format <URL:http://www.springeronline.com/lncs/>. Paper submission will be handled electronically by means of the Easychair system. The submission page is available at https://easychair.org/conferences/?conf=aspocp2016
Abstract and paper submission deadline: June 27, 2016
Notification: July 30, 2016
Camera-ready articles due: August 31, 2016
Workshop: October 16 or 17, 2016 (TBA)
Accepted papers will be made available online.
The workshop will be held in New York, collocated with
the International Conference on Logic Programming (ICLP) 2016.
WORKSHOP CO-CHAIRS
Bart Bogaerts, Aalto University, Finland
Amelia Harrison, University of Texas at Austin, USA
Rehan Abdul Aziz, University of Melbourne and National ICT Australia (NICTA)
Marcello Balduccini, Drexel University
Bart Bogaerts (chair), Department of Computer Science Aalto University
Gerhard Brewka, Leipzig University
Pedro Cabalar, University of Corunna
Sandeep Chintabathina, Hawaii Pacific University
Stefania Costantini, Dipartimento di Ingegneria e Scienze dell'Informazione e Matematica Univ. dell'Aquila
Esra Erdem, Sabanci University
Wolfgang Faber, University of Huddersfield
Cristina Feier, University of Bremen
Johannes Klaus Fichte, Institute of Information Systems Vienna University of Technology
Enrico Giunchiglia, DIST - Univ. Genova
Amelia Harrison (chair), University of Texas
Daniela Inclezan, Miami University
Tomi Janhunen, Aalto University
Joohyung Lee, Arizona State University
Nicola Leone, Department of Mathematics and Computer Science - University of Calabria
Vladimir Lifschitz, University of Texas
Marco Maratea, DIBRIS University of Genova
Alessandro Mosca, SIRIS Lab - Research division of SIRIS Academic SL
Max Ostrowski, University of Potsdam
Guillermo Simari, Dept. of Computer Science and Engineering Universidad Nacional del Sur in Bahia Blanca
Mirek Truszczynski, Computer Science Department University of Kentucky
Richard Watson, Texas Tech University Department of Computer Science
Stefan Woltran, TU Wien
Fangkai Yang, Schlumberger Limited
Jia-Huai You, Department of Computing Science University of Alberta